Fixed a bug where could not be accessed from a model object, and adjusted one test...
[openmx:openmx.git] / src / omxData.h
1 /*
2  *  Copyright 2007-2015 The OpenMx Project
3  *
4  *  Licensed under the Apache License, Version 2.0 (the "License");
5  *  you may not use this file except in compliance with the License.
6  *  You may obtain a copy of the License at
7  *
8  *       http://www.apache.org/licenses/LICENSE-2.0
9  *
10  *   Unless required by applicable law or agreed to in writing, software
11  *   distributed under the License is distributed on an "AS IS" BASIS,
12  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  *  See the License for the specific language governing permissions and
14  *  limitations under the License.
15  *
16  */
17
18 /***********************************************************
19  * 
20  *  omxData.h
21  *
22  *  Created: Timothy R. Brick   Date: 2009-07-15
23  *
24  *      Contains header information for the omxData class
25  *   omxData objects keep data objects in whatever form
26  *   they might take.
27  *
28  **********************************************************/
29
30 #ifndef _OMXDATA_H_
31 #define _OMXDATA_H_
32
33 #define R_NO_REMAP
34 #include <R.h>
35 #include <Rinternals.h> 
36 #include <R_ext/Rdynload.h> 
37 #include <R_ext/BLAS.h>
38 #include <R_ext/Lapack.h> 
39 #include "omxDefines.h"
40
41 typedef struct omxData omxData;
42 typedef struct omxContiguousData omxContiguousData;
43 typedef struct omxThresholdColumn omxThresholdColumn;
44
45
46 #include "omxAlgebra.h"
47 #include "omxFitFunction.h"
48 #include "omxState.h"
49
50 struct omxContiguousData {
51         int isContiguous;
52         int start;
53         int length;
54 };
55
56 struct omxThresholdColumn {
57
58         omxMatrix* matrix;              // Which Matrix/Algebra it comes from
59         int column;                             // Which column has the thresholds
60         int numThresholds;              // And how many thresholds
61
62         // for continuous variables, this structure is preserved all zero
63         omxThresholdColumn() : matrix(0), column(0), numThresholds(0) {};
64 };
65
66 struct ColumnData {
67         const char *name;
68         // exactly one of these is non-null
69         double *realData;
70         int    *intData;
71 };
72
73 class omxData {
74  private:
75         SEXP rownames;
76         void addDynamicDataSource(omxExpectation *ex);
77
78  public: // move everything to private TODO
79         const char *name;
80         SEXP dataObject;                                // only used for dynamic data
81         omxMatrix* dataMat;                             // do not use directly
82         omxMatrix* meansMat;                            // The means, as an omxMatrixObject
83         omxMatrix* acovMat;                                     // The asymptotic covariance, as an omxMatrixObject, added for ordinal WLS
84         omxMatrix* obsThresholdsMat;            // The observed thresholds, added for ordinal WLS
85         std::vector< omxThresholdColumn > thresholdCols;
86         double numObs;                                          // Number of observations (sum of rowWeight)
87         const char *_type;
88         const char *getType() const { return _type; };
89
90         // type=="raw"
91         std::vector<ColumnData> rawCols;
92         int numFactor, numNumeric;                      // Number of ordinal and continuous columns
93         bool isSorted;
94         int* indexVector;                                               // The "official" index into the data set
95         int* identicalDefs;                                     // Number of consecutive rows with identical def. vars
96         int* identicalMissingness;                      // Number of consecutive rows with identical missingness patterns
97         int* identicalRows;                                     // Number of consecutive rows with identical data
98  public:
99         int rows, cols;                                         // Matrix size 
100         int verbose;
101         omxState *currentState;
102
103         // Used when the expectation provides the observed data (DataDynamic)
104         std::vector<struct omxExpectation *> expectation;   // weak pointers
105         int version;
106
107         omxData(omxState *);
108         void newDataStatic(SEXP dataObject);
109         SEXP getRowNames();
110         void connectDynamicData();
111         void recompute();
112 };
113
114 omxData* omxNewDataFromMxData(SEXP dataObject, const char *name);
115
116 omxData* omxDataLookupFromState(SEXP dataObject, omxState* state);      // Retrieves a data object from the state
117 void omxFreeData(omxData* od);                                  // Release any held data.
118 void omxSetContiguousDataColumns(omxContiguousData* contiguous, omxData* data, omxMatrix* colList);
119
120 /* Getters 'n Setters */
121 static inline bool omxDataIsSorted(omxData* data) { return data->isSorted; }
122 double omxDoubleDataElement(omxData *od, int row, int col);
123 double *omxDoubleDataColumn(omxData *od, int col);
124 int omxIntDataElement(omxData *od, int row, int col);                                           // Returns one data object as an integer
125 omxMatrix* omxDataCovariance(omxData *od);
126 omxMatrix* omxDataMeans(omxData *od);
127 omxMatrix* omxDataAcov(omxData *od);                                            // Populates a matrix with the asymptotic covariance matrix
128
129 std::vector<omxThresholdColumn> &omxDataThresholds(omxData *od);
130
131 void omxDataRow(omxData *od, int row, omxMatrix* colList, omxMatrix* om);// Populates a matrix with a single data row
132 void omxContiguousDataRow(omxData *od, int row, int start, int length, omxMatrix* om);// Populates a matrix with a contiguous data row
133 int omxDataIndex(omxData *od, int row);                                                                         // Returns the unsorted (original) index of the current row
134 int omxDataNumIdenticalRows(omxData *od, int row);                                                      // Returns the number of rows identical to this one in the data set
135 int omxDataNumIdenticalMissingness(omxData *od, int row);                                       // Returns the number of rows with definition variables and missingness identical to this one in the data set
136 int omxDataNumIdenticalContinuousRows(omxData *od, int row);                // Number of rows with continuous variables remaining, or Inf if no continous vars
137 int omxDataNumIdenticalContinuousMissingness(omxData *od, int row);         // Number of rows with continuous variables remaining, or Inf if no continous vars
138 int omxDataNumIdenticalOrdinalRows(omxData *od, int row);
139 int omxDataNumIdenticalOrdinalMissingness(omxData *od, int row);
140 int omxDataNumIdenticalDefs(omxData *od, int row);                                                      // Returns the number of rows with definition variables identical to this one in the data set
141
142 static OMXINLINE int
143 omxIntDataElementUnsafe(omxData *od, int row, int col)
144 {
145         return od->rawCols[col].intData[row];
146 }
147
148 static OMXINLINE int *omxIntDataColumnUnsafe(omxData *od, int col)
149 {
150         return od->rawCols[col].intData;
151 }
152
153 double omxDataNumObs(omxData *od);                                                                                      // Returns number of obs in the dataset
154 bool omxDataColumnIsFactor(omxData *od, int col);
155 const char *omxDataColumnName(omxData *od, int col);
156 const char *omxDataType(omxData *od);                         // TODO: convert to ENUM
157         
158 int omxDataNumNumeric(omxData *od);                   // Number of numeric columns in the data set
159 int omxDataNumFactor(omxData *od);                    // Number of factor columns in the data set
160
161 void resetDefinitionVariables(double *oldDefs, int numDefs);
162
163 /* Function wrappers that switch based on inclusion of algebras */
164
165 void omxPrintData(omxData *od, const char *header, int maxRows);
166 void omxPrintData(omxData *od, const char *header);
167
168 double omxDataDF(omxData *od);
169
170 #endif /* _OMXDATA_H_ */