teradataml 20.0.0.8__py3-none-any.whl

teradataml/data/docs/uaf/docs_17_20/BinarySeriesOp.py

@@ -0,0 +1,252 @@
+def BinarySeriesOp(data1=None, data1_filter_expr=None, data2=None,
+                   data2_filter_expr=None, math_op=None,
+                   input_fmt_input_mode=None,
+                   output_fmt_index_style="NUMERICAL_SEQUENCE",
+                   **generic_arguments):
+    """
+    DESCRIPTION:
+        The BinarySeriesOp() function performs a point wise mathematical
+        operation on two time series of equal size.
+        The principal mathematical operation can be
+        subtraction, addition, multiplication and division.
+        It is called a point wise operation because it performs
+        the mathematical operation one sample point at a time.
+
+        For example, if the mathematical operation being performed is
+        subtraction, then for two series each with N sample points,
+        a new series is generated in which:
+            * ResultSeries1 =  MinuendSeries1 - SubtrahendSeries1
+            * ResultSeries2 =  MinuendSeries2 - SubtrahendSeries2
+            * ResultSeries3 =  MinuendSeries3 -SubtrahendSeries3
+            ... up to ...
+            * ResultSeriesN  = MinuendSeriesN  - SubtrahendSeriesN.
+
+        The result series/1D array produced by the BinarySeriesOp()
+        is of the same size 'N' as its inputs.
+
+        BinarySeriesOp() takes two equally sized logical-runtime series
+        as input:
+            * The first series referenced in the function call as "data1"
+              is referred as the primary series.
+            * The second series referenced in the function call as "data2"
+              is referred as the secondary series.
+        The result series always inherits the identifiers,
+        series_id from the primary series.
+
+        The BinarySeriesOp() function can be configured to
+        operate in one of three input modes - ONE2ONE, MANY2ONE,
+        and MATCH. These modes determine the number of primary
+        series and number of secondary series involved in the
+        operation, as well as determining how the primary and
+        secondary series will be matched together.
+
+        Common uses of BinarySeriesOp() are:
+            1. Subtracting trends from a time series to create a model from it.
+            2. Restoring trends to a time series before using the model for
+               forecasting.
+            3. As a building block to formulate more complex
+               functions.
+
+        For example, convolving in the time domain is point-wise multiplication
+        in the frequency domain.
+        The following procedure is an example of how
+        to use BinarySeriesOp() to convolve two series with
+        digital signal processing:
+            1. Use DFFT() function on series 1 and series 2 to get dataframes
+               named 'dfftRes1' and 'dfftRes2', respectively.
+            2. Use BinarySeriesOp() to do point-wise multiplication
+               using 'dfftRes1' and 'dfftRes2'.
+            3. Use IDFFT() on the output of BinarySeriesOp() to get the
+               convolved result of the two series.
+
+    PARAMETERS:
+        data1:
+            Required Argument.
+            Specifies the primary series in the mathematical operation.
+            The first input is measured against the second input.
+            This series must have the same size as that of the
+            second input series specified in "data2".
+            Input values are REAL and MUTLIVAR_REAL.
+            Function supports one input being univariate and the other being
+            multivariate. In particular, the following combinations are
+            supported:
+                1. For all MULTIVAR varieties: Both multivariate series
+                   are of the same content type and both series have
+                   the same number of payload fields.
+                2. For MULTIVAR_REAL: One input is a MULTIVAR content series
+                   having greater than one payload field and the other series
+                   is a REAL content series having just one payload field.
+                3. For the MULTIVAR_AMPL_PHASE and MULTIVAR_COMPLEX varieties:
+                   One input is a MULTIVAR content series having greater than one
+                   pair of fields and the other series is a MULTIVAR content of
+                   the same type having one pair of payload fields.
+            Types: TDSeries
+
+        data1_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data1".
+            Types: ColumnExpression
+
+        data2:
+            Required Argument.
+            Specifies the secondary series of equal size to be operated on.
+            This series must have the same size as that of the
+            first input series specified in "data1".
+            Input values are REAL and MUTLIVAR_REAL.
+            Function supports one input being univariate and the other being
+            multivariate. In particular, the following combinations are
+            supported:
+                1. For all MULTIVAR varieties: Both multivariate series
+                   are of the same content type and both series have
+                   the same number of payload fields.
+                2. For MULTIVAR_REAL: One input is a MULTIVAR content series
+                   having greater than one payload field and the other series
+                   is a REAL content series having just one payload field.
+                3. For the MULTIVAR_AMPL_PHASE and MULTIVAR_COMPLEX varieties:
+                   One input is a MULTIVAR content series having greater than one
+                   pair of fields and the other series is a MULTIVAR content of
+                   the same type having one pair of payload fields.
+            Types: TDSeries
+
+        data2_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data2".
+            Types: ColumnExpression
+
+        math_op:
+            Required Argument.
+            Specifies the mathematical operation to be performed
+            between the series passed in "data1" and "data2".
+            Permitted Values:
+                SUB: Subtract trends from a time series to create a model from it.
+                     The series in "data2" is subtracted from the series
+                     in "data1".
+                ADD: Restore trends to a time series before using the model for forecasting.
+                MUL: Apply a low pass, band pass, or high pass filter to a time series.
+                DIV: The series in "data1" is divided by the series
+                     in "data2".
+            Types: str
+
+        input_fmt_input_mode:
+            Required Argument.
+            Specifies the input mode supported by the function.
+            Permitted Values:
+                * ONE2ONE: Both the primary and secondary series
+                           specifications contain a series name
+                           which identifies the two series in the function.
+                * MANY2ONE: The MANY specification is the primary series declaration.
+                            The secondary series specification contains a series name
+                            that identifies the single secondary matrix.
+                * MATCH: Both series are defined by their respective
+                         series id declarations.
+            Types: str
+
+        output_fmt_index_style:
+            Optional Argument.
+            Specifies the index style of the output format.
+            Permitted Values: NUMERICAL_SEQUENCE, FLOW_THROUGH
+            Default Value: NUMERICAL_SEQUENCE
+            Types: str
+
+        **generic_arguments:
+            Specifies the generic keyword arguments of UAF functions.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the
+                    function in a table or not. When set to True,
+                    results are persisted in a table; otherwise,
+                    results are garbage collected at the end of the
+                    session.
+                    Note that, when UAF function is executed, an
+                    analytic result table (ART) is created.
+                    Default Value: False
+                    Types: bool
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the
+                    function in a volatile ART or not. When set to
+                    True, results are stored in a volatile ART,
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+
+                output_table_name:
+                    Optional Argument.
+                    Specifies the name of the table to store results.
+                    If not specified, a unique table name is internally
+                    generated.
+                    Types: str
+
+                output_db_name:
+                    Optional Argument.
+                    Specifies the name of the database to create output
+                    table into. If not specified, table is created into
+                    database specified by the user at the time of context
+                    creation or configuration parameter. Argument is ignored,
+                    if "output_table_name" is not specified.
+                    Types: str
+
+
+    RETURNS:
+        Instance of BinarySeriesOp.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as BinarySeriesOp_obj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. result
+
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Check the list of available UAF analytic functions.
+        display_analytic_functions(type="UAF")
+
+        # Load the example data.
+        load_example_data("uaf", ["binary_complex_left", "binary_complex_right"])
+
+        # Create teradataml DataFrame objects.
+        data1 = DataFrame.from_table("binary_complex_left")
+        data2 = DataFrame.from_table("binary_complex_right")
+
+        # Create teradataml TDSeries objects.
+        data1_series_df = TDSeries(data=data1,
+                                   id="id",
+                                   row_index="seq",
+                                   row_index_style="SEQUENCE",
+                                   payload_field=["real_val", "imaginary_val"],
+                                   payload_content="COMPLEX")
+
+        data2_series_df = TDSeries(data=data2,
+                                   id="id",
+                                   row_index="seq",
+                                   row_index_style= "SEQUENCE",
+                                   payload_field=["real_val", "imaginary_val"],
+                                   payload_content="COMPLEX")
+
+        # Form the filter expressions to filter the series with id=1.
+        data1_filter_expr=data1_series_df.id==1
+        data2_filter_expr=data2_series_df.id==1
+
+        # Example 1: Perform addition of two time series of equal size.
+        uaf_out = BinarySeriesOp(data1=data1_series_df,
+                                 data1_filter_expr=data1_filter_expr,
+                                 data2=data2_series_df,
+                                 data2_filter_expr=data2_filter_expr,
+                                 math_op="ADD",
+                                 input_fmt_input_mode="MANY2ONE")
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+
+    """

teradataml/data/docs/uaf/docs_17_20/BreuschGodfrey.py

@@ -0,0 +1,178 @@
+def BreuschGodfrey(data=None, data_filter_expr=None, residual_max_lags=None,
+                   explanatory_count=None, significance_level=0.05,
+                   **generic_arguments):
+    """
+    DESCRIPTION:
+        The BreuschGodfrey() function checks for the presence of serial correlation
+        among the residual and error terms after running a regression
+        associated with a fitted model. With respect to regression models,
+        it is expected that there is no serial correlation among the error terms.
+
+        The following procedure is an example of how to use BreuschGodfrey:
+            * Use LinearRegr() for regression testing.
+            * Use BreuschGodfrey() on the result from LinearRegr() to
+              compute the test statistics and determine if there is serial correlation.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the residual multivariate series
+            or TDAnalyticResult object on the output generated
+            by the UAF function.
+            Types: TDSeries, TDAnalyticResult
+
+        data_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data".
+            Types: ColumnExpression
+
+        residual_max_lags:
+            Required Argument.
+            Specifies the maximum lag number for the
+            residuals used in the auxiliary regression. It also
+            determines degrees of freedom associated with the test.
+            Types: int
+
+        explanatory_count:
+            Required Argument.
+            Specifies the number of explanatory variables that are present
+            in the original regression plus '1' if a constant is
+            present.
+            Example: If the "formula" parameter used in LinearRegr() is 'Y = B0 + B1*X1',
+            it has "explanatory_count" of '2', '1' for 'X1' and '1' for the
+            constant 'B0'.
+            Types: int
+
+        significance_level:
+            Optional Argument.
+            Specifies the desired significance level for the test.
+            Default Value: 0.05
+            Types: float
+
+        **generic_arguments:
+            Specifies the generic keyword arguments of UAF functions.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the
+                    function in a table or not. When set to True,
+                    results are persisted in a table; otherwise,
+                    results are garbage collected at the end of the
+                    session.
+                    Note that, when UAF function is executed, an
+                    analytic result table (ART) is created.
+                    Default Value: False
+                    Types: bool
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the
+                    function in a volatile ART or not. When set to
+                    True, results are stored in a volatile ART,
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+
+                output_table_name:
+                    Optional Argument.
+                    Specifies the name of the table to store results.
+                    If not specified, a unique table name is internally
+                    generated.
+                    Types: str
+
+                output_db_name:
+                    Optional Argument.
+                    Specifies the name of the database to create output
+                    table into. If not specified, table is created into
+                    database specified by the user at the time of context
+                    creation or configuration parameter. Argument is ignored,
+                    if "output_table_name" is not specified.
+                    Types: str
+
+    RETURNS:
+        Instance of BreuschGodfrey.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as BreuschGodfrey_obj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. result
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Check the list of available UAF analytic functions.
+        display_analytic_functions(type="UAF")
+
+        # Load the example data.
+        load_example_data("uaf", ["house_values"])
+
+        # Create teradataml DataFrame object.
+        data = DataFrame.from_table("house_values")
+
+        # Execute LinearRegr() function to fit house_values data to
+        # the curve mentioned in the "formula" for cityid 33. It returns
+        # a result containing solved coefficients, model statistics,
+        # and residuals statistics.
+        # Create teradataml TDSeries object.
+        data_series_df = TDSeries(data=data,
+                                  id="cityid",
+                                  row_index="TD_TIMECODE",
+                                  row_index_style="TIMECODE",
+                                  payload_field=["salary","house_val"],
+                                  payload_content="MULTIVAR_REAL")
+
+        filter_expr = data_series_df.cityid==33
+        linear_regr_result = LinearRegr(data=data_series_df,
+                                        data_filter_expr=filter_expr,
+                                        formula = "Y = B0 + B1*X1",
+                                        weights=False,
+                                        algorithm='QR',
+                                        coeff_stats=True,
+                                        variables_count=2,
+                                        model_stats=True,
+                                        residuals=True)
+
+        # Example 1: Compute the serial correlation among the residual
+        #            and error terms. Input is teradataml TDAnalyticResult
+        #            object over the output generated by running a linear
+        #            regression associated with a fitted model.
+
+        # Create teradataml TDAnalyticResult object.
+        data_art_df =  TDAnalyticResult(data=linear_regr_result.result)
+        uaf_out = BreuschGodfrey(data=data_art_df,
+                                 explanatory_count=2,
+                                 residual_max_lags=1,
+                                 significance_level=.01)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+
+        # Example 2: Compute the serial correlation among the residual
+        #            and error terms. Input is teradataml TDSeries
+        #            object over the "fitresiduals" dataframe generated
+        #            by running a linear regression associated
+        #            with a fitted model.
+
+        data_series_bg = TDSeries(data=linear_regr_result.fitresiduals,
+                                  id="cityid",
+                                  row_index="ROW_I",
+                                  row_index_style= "SEQUENCE",
+                                  payload_field=["RESIDUAL","ACTUAL_VALUE","CALC_VALUE"],
+                                  payload_content="MULTIVAR_REAL")
+
+        uaf_out = BreuschGodfrey(data=data_series_bg,
+                                 explanatory_count=2,
+                                 residual_max_lags=1,
+                                 significance_level=.01)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+
+    """

teradataml/data/docs/uaf/docs_17_20/BreuschPaganGodfrey.py

@@ -0,0 +1,175 @@
+def BreuschPaganGodfrey(data=None, data_filter_expr=None, variables_count=None, 
+                        formula=None, studentize=False,
+                        significance_level=0.05, **generic_arguments):
+    """
+    DESCRIPTION:
+        The BreuschPaganGodfrey() function checks for heteroscedasticity using 
+        one or more variables among the residual terms after running a regression.
+
+        The following procedure is an example of how to use BreuschPaganGodfrey() function:
+            * Use MultivarRegr() to create regression model and generate residuals.
+            * Use BreuschPaganGodfrey() on the output DataFrame from MultivarRegr().
+            * Check the 'NULL_HYPOTHESIS' value to determine if there is heteroscedasticity. 
+              ACCEPT means that variance is homoscedastic. 
+              REJECT means that variance is heteroscedastic.       
+            
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the residual multivariate series or 
+            TDAnalyticResult object created over output 
+            generated by the UAF regression function.
+            Types: TDSeries, TDAnalyticResult
+
+        data_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data".
+            Types: ColumnExpression
+
+        variables_count:
+            Required Argument.
+            Specifies the number of explanatory variables 
+            that are used in the auxiliary regression.
+            Types: int
+
+        formula:
+            Optional Argument.
+            Specifies the regression formula to use for the 
+            auxiliary regression. If a formula is not included, 
+            then the default regression formula is used.
+            Types: str
+
+        studentize:
+            Optional Argument.
+            Specifies whether to use the Koenker studentized 
+            version of the Breusch-Pagan-Godfrey (BPG) test.   
+            When set to True, Koenker studentized version is 
+            used, otherwise the standard BPG test is used.
+            Default Value: False
+            Types: bool
+
+        significance_level:
+            Optional Argument.
+            Specifies the desired significance level for the test.
+            Default Value: 0.05
+            Types: float
+
+        **generic_arguments:
+            Specifies the generic keyword arguments of UAF functions.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the
+                    function in a table or not. When set to True,
+                    results are persisted in a table; otherwise,
+                    results are garbage collected at the end of the
+                    session.
+                    Note that, when UAF function is executed, an 
+                    analytic result table (ART) is created.
+                    Default Value: False
+                    Types: bool
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the
+                    function in a volatile ART or not. When set to
+                    True, results are stored in a volatile ART,
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+
+                output_table_name:
+                    Optional Argument.
+                    Specifies the name of the table to store results. 
+                    If not specified, a unique table name is internally 
+                    generated.
+                    Types: str
+
+                output_db_name:
+                    Optional Argument.
+                    Specifies the name of the database to create output 
+                    table into. If not specified, table is created into 
+                    database specified by the user at the time of context 
+                    creation or configuration parameter. Argument is ignored,
+                    if "output_table_name" is not specified.
+                    Types: str
+
+
+    RETURNS:
+        Instance of BreuschPaganGodfrey.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as BreuschPaganGodfrey_obj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. result
+
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Check the list of available UAF analytic functions.
+        display_analytic_functions(type="UAF")
+
+        # Load the example data.
+        load_example_data("uaf", ["house_values"])
+
+        # Create teradataml DataFrame object.
+        data = DataFrame.from_table("house_values")
+
+        # Create teradataml TDSeries object.
+        data_series_df = TDSeries(data=data,
+                                  id="cityid",
+                                  row_index="TD_TIMECODE",
+                                  payload_field=["house_val","salary","mortgage"],
+                                  payload_content="MULTIVAR_REAL")
+
+        # Create Multivariate regression model.
+        mvr_out = MultivarRegr(data=data_series_df,
+                               variables_count=3,
+                               weights=False,
+                               formula="Y = B0 + B1*X1 + B2*X2",
+                               algorithm='QR',
+                               coeff_stats=True,
+                               model_stats=True,
+                               residuals=True)
+        
+        # Example 1: Perform Breusch-Pagan-Godfrey (BPG) test using input as teradataml 
+        #            TDSeries object generated from model residuals.
+        # Extract residuals from the model as TDSeries.
+        data_series_bg = TDSeries(data=mvr_out.fitresiduals,
+                                  id="cityid",
+                                  row_index="ROW_I",
+                                  row_index_style= "SEQUENCE",
+                                  payload_field=["RESIDUAL","ACTUAL_VALUE","CALC_VALUE"],
+                                  payload_content="MULTIVAR_REAL")
+        uaf_out = BreuschPaganGodfrey(data=data_series_bg,
+                                      variables_count=2,
+                                      significance_level=0.01)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+        
+        # Example 2: Perform Koenker studentized version of the Breusch-Pagan-Godfrey 
+        #            (BPG) test using input as teradataml TDAnalyticResult object
+        #            generated from model output.
+        # Create teradataml TDAnalyticResult object from model output.
+        data_art_df =  TDAnalyticResult(data=mvr_out.result)
+        uaf_out = BreuschPaganGodfrey(data=data_art_df,
+                                      variables_count=2,
+                                      studentize=True,
+                                      significance_level=0.01)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+    
+    """
+