org.apache.spark.ml.feature

Class RFormulaParser

Object

org.apache.spark.ml.feature.RFormulaParser

public class RFormulaParser
extends Object

Limited implementation of R formula parsing. Currently supports: '~', '+', '-', '.', ':', '*', '^'.

Constructor Summary

Constructors

Constructor and Description
RFormulaParser()

Method Summary

Modifier and Type	Method and Description
static <ES> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<Object>>	accept(ES es, scala.Function1<ES,scala.collection.immutable.List<Object>> f)
static scala.util.parsing.combinator.Parsers.Parser<Object>	accept(scala.util.parsing.combinator.Parsers e)
static <U> scala.util.parsing.combinator.Parsers.Parser<U>	accept(String expected, scala.PartialFunction<Object,U> f)
static scala.util.parsing.combinator.Parsers.Parser<Object>	acceptIf(scala.Function1<Object,Object> p, scala.Function1<Object,String> err)
static <U> scala.util.parsing.combinator.Parsers.Parser<U>	acceptMatch(String expected, scala.PartialFunction<Object,U> f)
static <ES> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<Object>>	acceptSeq(ES es, scala.Function1<ES,scala.collection.Iterable<Object>> f)
static <T> scala.util.parsing.combinator.Parsers.Parser<T>	chainl1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p, scala.Function0<scala.util.parsing.combinator.Parsers.Parser<scala.Function2<T,T,T>>> q)
static <T,U> scala.util.parsing.combinator.Parsers.Parser<T>	chainl1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> first, scala.Function0<scala.util.parsing.combinator.Parsers.Parser<U>> p, scala.Function0<scala.util.parsing.combinator.Parsers.Parser<scala.Function2<T,U,T>>> q)
static <T,U> scala.util.parsing.combinator.Parsers.Parser<U>	chainr1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p, scala.Function0<scala.util.parsing.combinator.Parsers.Parser<scala.Function2<T,U,U>>> q, scala.Function2<T,U,U> combine, U first)
static <T> scala.util.parsing.combinator.Parsers.Parser<T>	commit(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)
static scala.util.parsing.combinator.Parsers.Parser<Object>	elem(scala.util.parsing.combinator.Parsers e)
static scala.util.parsing.combinator.Parsers.Parser<Object>	elem(String kind, scala.Function1<Object,Object> p)
static scala.util.parsing.combinator.Parsers.Parser<scala.runtime.Nothing$>	err(String msg)
static scala.util.parsing.combinator.Parsers.Error$	Error()
static scala.util.parsing.combinator.Parsers.Failure$	Failure()
static scala.util.parsing.combinator.Parsers.Parser<scala.runtime.Nothing$>	failure(String msg)
static <T> scala.util.parsing.combinator.Parsers.Parser<T>	guard(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)
static scala.util.parsing.combinator.Parsers.Parser<String>	literal(String s)
static <T> scala.util.parsing.combinator.Parsers.Parser<T>	log(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p, String name)
static <T> scala.Function1<scala.util.parsing.combinator.Parsers.$tilde<T,scala.collection.immutable.List<T>>,scala.collection.immutable.List<T>>	mkList()
static scala.util.parsing.combinator.Parsers.NoSuccess$	NoSuccess()
static <T> scala.util.parsing.combinator.Parsers.Parser<scala.runtime.BoxedUnit>	not(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)
static <T> scala.util.parsing.combinator.Parsers.Parser<T>	OnceParser(scala.Function1<scala.util.parsing.input.Reader<Object>,scala.util.parsing.combinator.Parsers.ParseResult<T>> f)
static <T> scala.util.parsing.combinator.Parsers.Parser<scala.Option<T>>	opt(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)
static org.apache.spark.ml.feature.ParsedRFormula	parse(String value)
static <T> scala.util.parsing.combinator.Parsers.ParseResult<T>	parseAll(scala.util.parsing.combinator.Parsers.Parser<T> p, CharSequence in)
static <T> scala.util.parsing.combinator.Parsers.ParseResult<T>	parseAll(scala.util.parsing.combinator.Parsers.Parser<T> p, java.io.Reader in)
static <T> scala.util.parsing.combinator.Parsers.ParseResult<T>	parseAll(scala.util.parsing.combinator.Parsers.Parser<T> p, scala.util.parsing.input.Reader<Object> in)
static <T> scala.util.parsing.combinator.Parsers.Parser<T>	Parser(scala.Function1<scala.util.parsing.input.Reader<Object>,scala.util.parsing.combinator.Parsers.ParseResult<T>> f)
static <T> scala.util.parsing.combinator.Parsers.Parser<T>	phrase(scala.util.parsing.combinator.Parsers.Parser<T> p)
static <T extends scala.util.parsing.input.Positional> scala.util.parsing.combinator.Parsers.Parser<T>	positioned(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)
static scala.util.parsing.combinator.Parsers.Parser<String>	regex(scala.util.matching.Regex r)
static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>>	rep(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)
static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>>	rep1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)
static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>>	rep1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> first, scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p0)
static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>>	rep1sep(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p, scala.Function0<scala.util.parsing.combinator.Parsers.Parser<Object>> q)
static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>>	repN(int num, scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)
static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>>	repNM(int n, int m, scala.util.parsing.combinator.Parsers.Parser<T> p, scala.util.parsing.combinator.Parsers.Parser<Object> sep)
static <T> scala.util.parsing.combinator.Parsers.Parser<Object>	repNM$default$4()
static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>>	repsep(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p, scala.Function0<scala.util.parsing.combinator.Parsers.Parser<Object>> q)
static boolean	skipWhitespace()
static scala.util.parsing.combinator.Parsers.Success$	Success()
static <T> scala.util.parsing.combinator.Parsers.Parser<T>	success(T v)

Methods inherited from class Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

RFormulaParser

public RFormulaParser()

Method Detail

Success

public static scala.util.parsing.combinator.Parsers.Success$ Success()

NoSuccess

public static scala.util.parsing.combinator.Parsers.NoSuccess$ NoSuccess()

Failure

public static scala.util.parsing.combinator.Parsers.Failure$ Failure()

Error

public static scala.util.parsing.combinator.Parsers.Error$ Error()

parse

public static org.apache.spark.ml.feature.ParsedRFormula parse(String value)

Parser

public static <T> scala.util.parsing.combinator.Parsers.Parser<T> Parser(scala.Function1<scala.util.parsing.input.Reader<Object>,scala.util.parsing.combinator.Parsers.ParseResult<T>> f)

OnceParser

public static <T> scala.util.parsing.combinator.Parsers.Parser<T> OnceParser(scala.Function1<scala.util.parsing.input.Reader<Object>,scala.util.parsing.combinator.Parsers.ParseResult<T>> f)

commit

public static <T> scala.util.parsing.combinator.Parsers.Parser<T> commit(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)

elem

public static scala.util.parsing.combinator.Parsers.Parser<Object> elem(String kind,
                                                                        scala.Function1<Object,Object> p)

elem

public static scala.util.parsing.combinator.Parsers.Parser<Object> elem(scala.util.parsing.combinator.Parsers e)

accept

public static scala.util.parsing.combinator.Parsers.Parser<Object> accept(scala.util.parsing.combinator.Parsers e)

accept

public static <ES> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<Object>> accept(ES es,
                                                                                                                scala.Function1<ES,scala.collection.immutable.List<Object>> f)

accept

public static <U> scala.util.parsing.combinator.Parsers.Parser<U> accept(String expected,
                                                                         scala.PartialFunction<Object,U> f)

acceptIf

public static scala.util.parsing.combinator.Parsers.Parser<Object> acceptIf(scala.Function1<Object,Object> p,
                                                                            scala.Function1<Object,String> err)

acceptMatch

public static <U> scala.util.parsing.combinator.Parsers.Parser<U> acceptMatch(String expected,
                                                                              scala.PartialFunction<Object,U> f)

acceptSeq

public static <ES> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<Object>> acceptSeq(ES es,
                                                                                                                   scala.Function1<ES,scala.collection.Iterable<Object>> f)

failure

public static scala.util.parsing.combinator.Parsers.Parser<scala.runtime.Nothing$> failure(String msg)

success

public static <T> scala.util.parsing.combinator.Parsers.Parser<T> success(T v)

log

public static <T> scala.util.parsing.combinator.Parsers.Parser<T> log(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p,
                                                                      String name)

rep

public static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>> rep(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)

repsep

public static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>> repsep(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p,
                                                                                                          scala.Function0<scala.util.parsing.combinator.Parsers.Parser<Object>> q)

rep1

public static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>> rep1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)

rep1

public static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>> rep1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> first,
                                                                                                        scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p0)

repN

public static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>> repN(int num,
                                                                                                        scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)

repNM

public static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>> repNM(int n,
                                                                                                         int m,
                                                                                                         scala.util.parsing.combinator.Parsers.Parser<T> p,
                                                                                                         scala.util.parsing.combinator.Parsers.Parser<Object> sep)

repNM$default$4

public static <T> scala.util.parsing.combinator.Parsers.Parser<Object> repNM$default$4()

rep1sep

public static <T> scala.util.parsing.combinator.Parsers.Parser<scala.collection.immutable.List<T>> rep1sep(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p,
                                                                                                           scala.Function0<scala.util.parsing.combinator.Parsers.Parser<Object>> q)

chainl1

public static <T> scala.util.parsing.combinator.Parsers.Parser<T> chainl1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p,
                                                                          scala.Function0<scala.util.parsing.combinator.Parsers.Parser<scala.Function2<T,T,T>>> q)

chainl1

public static <T,U> scala.util.parsing.combinator.Parsers.Parser<T> chainl1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> first,
                                                                            scala.Function0<scala.util.parsing.combinator.Parsers.Parser<U>> p,
                                                                            scala.Function0<scala.util.parsing.combinator.Parsers.Parser<scala.Function2<T,U,T>>> q)

chainr1

public static <T,U> scala.util.parsing.combinator.Parsers.Parser<U> chainr1(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p,
                                                                            scala.Function0<scala.util.parsing.combinator.Parsers.Parser<scala.Function2<T,U,U>>> q,
                                                                            scala.Function2<T,U,U> combine,
                                                                            U first)

opt

public static <T> scala.util.parsing.combinator.Parsers.Parser<scala.Option<T>> opt(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)

not

public static <T> scala.util.parsing.combinator.Parsers.Parser<scala.runtime.BoxedUnit> not(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)

guard

public static <T> scala.util.parsing.combinator.Parsers.Parser<T> guard(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)

mkList

public static <T> scala.Function1<scala.util.parsing.combinator.Parsers.$tilde<T,scala.collection.immutable.List<T>>,scala.collection.immutable.List<T>> mkList()

skipWhitespace

public static boolean skipWhitespace()

literal

public static scala.util.parsing.combinator.Parsers.Parser<String> literal(String s)

regex

public static scala.util.parsing.combinator.Parsers.Parser<String> regex(scala.util.matching.Regex r)

positioned

public static <T extends scala.util.parsing.input.Positional> scala.util.parsing.combinator.Parsers.Parser<T> positioned(scala.Function0<scala.util.parsing.combinator.Parsers.Parser<T>> p)

err

public static scala.util.parsing.combinator.Parsers.Parser<scala.runtime.Nothing$> err(String msg)

phrase

public static <T> scala.util.parsing.combinator.Parsers.Parser<T> phrase(scala.util.parsing.combinator.Parsers.Parser<T> p)

parseAll

public static <T> scala.util.parsing.combinator.Parsers.ParseResult<T> parseAll(scala.util.parsing.combinator.Parsers.Parser<T> p,
                                                                                scala.util.parsing.input.Reader<Object> in)

parseAll

public static <T> scala.util.parsing.combinator.Parsers.ParseResult<T> parseAll(scala.util.parsing.combinator.Parsers.Parser<T> p,
                                                                                java.io.Reader in)

parseAll

public static <T> scala.util.parsing.combinator.Parsers.ParseResult<T> parseAll(scala.util.parsing.combinator.Parsers.Parser<T> p,
                                                                                CharSequence in)