loge                  package:VGAM                  R Documentation

_L_o_g _l_i_n_k _f_u_n_c_t_i_o_n

_D_e_s_c_r_i_p_t_i_o_n:

     Computes the log transformation, including its inverse and the
     first two derivatives.

_U_s_a_g_e:

     loge(theta, earg = list(), inverse = FALSE, deriv = 0,
          short = TRUE, tag = FALSE)
     nloge(theta, earg = list(), inverse = FALSE, deriv = 0,
           short = TRUE, tag = FALSE)

_A_r_g_u_m_e_n_t_s:

   theta: Numeric or character. See below for further details.

    earg: Optional list. Extra argument for passing in additional
          information. Values of 'theta' which are less than or equal
          to 0 can be replaced by the 'bvalue' component of the list
          'earg' before computing the link function value. The
          component name 'bvalue' stands for ``boundary value''. See
          'Links' for general information about 'earg'.

 inverse: Logical. If 'TRUE' the inverse function is computed. 

   deriv: Order of the derivative. Integer with value 0, 1 or 2. 

   short: Used for labelling the 'blurb' slot of a 'vglmff-class'
          object.

     tag: Used for labelling the linear/additive predictor in the
          'initialize' slot of a 'vglmff-class' object. Contains a
          little more information if 'TRUE'.

_D_e_t_a_i_l_s:

     The log link function is very commonly used for parameters that
     are positive. Numerical values of 'theta' close to 0 or out of
     range result in 'Inf', '-Inf', 'NA' or 'NaN'. The arguments
     'short' and 'tag' are used only if 'theta' is character.

     The function 'loge' computes log(theta) whereas 'nloge' computes
     -log(theta)=log(1/theta).

_V_a_l_u_e:

     The following concerns 'loge'. For 'deriv = 0', the log of
     'theta', i.e., 'log(theta)' when 'inverse = FALSE', and if
     'inverse = TRUE' then 'exp(theta)'. For 'deriv = 1', then the
     function returns _d_ 'theta' / _d_ 'eta' as a function of 'theta'
     if 'inverse = FALSE', else if 'inverse = TRUE' then it returns the
     reciprocal.

     Here, all logarithms are natural logarithms, i.e., to base e.

_N_o_t_e:

     This function is called 'loge' to avoid conflict with the 'log'
     function.

     Numerical instability may occur when 'theta' is close to 0 unless
     'earg' is used.

_A_u_t_h_o_r(_s):

     Thomas W. Yee

_R_e_f_e_r_e_n_c_e_s:

     McCullagh, P. and Nelder, J. A. (1989) _Generalized Linear
     Models_, 2nd ed. London: Chapman & Hall.

_S_e_e _A_l_s_o:

     'Links', 'logit', 'logc', 'loglog', 'log', 'logoff'.

_E_x_a_m_p_l_e_s:

     ## Not run: 
     loge(seq(-0.2, 0.5, by=0.1))
     loge(seq(-0.2, 0.5, by=0.1), earg=list(bvalue= .Machine$double.xmin))
     nloge(seq(-0.2, 0.5, by=0.1))
     nloge(seq(-0.2, 0.5, by=0.1), earg=list(bvalue= .Machine$double.xmin))
     ## End(Not run)

