# binseqtest-internal

##### Internal functions

Internal functions, not to be called by user

##### Usage

```
validAbparms(object)
validBound(object)
validBoundEst(object)
validBoundNBF(object)
abBindBothCalcK(object)
abtoBound(from)
pCalc(S,N,K,order,theta0=.5,alternative="two.sided",ponly=FALSE)
ciCalc(S,N,K,order,type="upper",alpha=0.025)
missNAbparms(ab,missN=NULL,...)
```

##### Arguments

- object
- object, usually a boundary of some class
- from
- an object of class abparms
- S
- vector of number of successes
- N
- vector of number of trials
- K
- vector of number of ways to reach each bounary point
- order
- vector of ordering of boundary points
- theta0
- null value of probability of success each binary random variable
- alternative
- character, either 'two.sided', 'less', or 'greater'
- ponly
- logical, should only the specific p-value type given by alternative be calculated
- type
- character, type of one-sided confidence interval to calculate, either 'upper' or 'lower'
- alpha
- numeric, amount of error to allow on the one side of the confidence interval
- ab
- object of class 'abparms'
- missN
- numeric vector, the N values where assessments are missed
- ...
- arguments passed to other functions, not used

##### Details

The validXX functions check that the object is a valid member of the class XX. For example, validBound checks that a bound object is OK by sum the probability distribution using the N,S, and K values and checking that it is within computer error of 1. The validity checks are run automatically by the new() function as part of the S4 implementation.

The function `abBindBothCalcK`

takes an abparms object and creates a bound object. It requires calculating K, which is the number of ways
to reach each boundary point. It ignores the `binding`

argument and assumes all boundaries are binding. The `abtoBound`

function
uses the `binding`

argument to create either a `bound`

object (for `binding`

='both') or a `boundNBF`

object otherwise.
Users can use the `as`

function to coerce an `abparms`

object to a `bound`

object.

The function `pCalc`

takes a boundary and calculates p-values, and outputs a vector of p-values (ponly=TRUE) or list of 3 vectors (plower,pupper, pval).

The function `cCalc`

takes a boundary and calculates one of the one sided confidence intervals as directed by the type argument (either 'upper' or 'lower').

The functions `analyzeBound`

and `analyzeBoundNBF`

take objects of the
`bound`

and `boundNBF`

classes and create ones of the `boundEst`

and
`boundNBFEst`

classes. This means basically that the confidence intervals and p-values
are calculated that go with those bounds.

The functions `getAlternative`

and `getTSalpha`

get those parameters from the inputs.

The function `missNAbparms`

modifies abparms objects to reflect missing assessments. This is the working function for the missN option in `modify`

.

*Documentation reproduced from package binseqtest, version 1.0.3, License: GPL-3*