Revision 1942 trunk/src/nh99/model11.cpp
model11.cpp (revision 1942)  

84  84 
this>dvar_matrix::operator=(m); 
85  85 
return *this; 
86  86 
} 
87 
named_dvar_matrix& named_dvar_matrix::operator = (CGNU_DOUBLE m)


87 
named_dvar_matrix& named_dvar_matrix::operator=(const double m)


88  88 
{ 
89  89 
this>dvar_matrix::operator=(m); 
90  90 
return *this; 
...  ...  
107  107 
this>dvar_matrix::operator=(m); 
108  108 
return *this; 
109  109 
} 
110 
param_stddev_matrix& param_stddev_matrix::operator = (CGNU_DOUBLE m)


110 
param_stddev_matrix& param_stddev_matrix::operator=(const double m)


111  111 
{ 
112  112 
this>dvar_matrix::operator=(m); 
113  113 
return *this; 
...  ...  
129  129 
this>dvar_vector::operator=(m); 
130  130 
return *this; 
131  131 
} 
132 
named_dvar_vector& named_dvar_vector::operator = (CGNU_DOUBLE m)


132 
named_dvar_vector& named_dvar_vector::operator=(const double m)


133  133 
{ 
134  134 
this>dvar_vector::operator=(m); 
135  135 
return *this; 
...  ...  
146  146 
this>dvector::operator=(m); 
147  147 
return *this; 
148  148 
} 
149 
named_dvector& named_dvector::operator = (CGNU_DOUBLE m)


149 
named_dvector& named_dvector::operator=(const double m)


150  150 
{ 
151  151 
this>dvector::operator=(m); 
152  152 
return *this; 
...  ...  
157  157 
this>dvector::operator=(m); 
158  158 
return *this; 
159  159 
} 
160 
data_vector& data_vector::operator = (CGNU_DOUBLE m)


160 
data_vector& data_vector::operator=(const double m)


161  161 
{ 
162  162 
this>dvector::operator=(m); 
163  163 
return *this; 
...  ...  
169  169 
this>dvar_vector::operator=(m); 
170  170 
return *this; 
171  171 
} 
172 
param_stddev_vector& param_stddev_vector::operator = (CGNU_DOUBLE m)


172 
param_stddev_vector& param_stddev_vector::operator=(const double m)


173  173 
{ 
174  174 
this>dvar_vector::operator=(m); 
175  175 
return *this; 
176  176 
} 
177  177  
178 
param_init_number& param_init_number::operator = (CGNU_DOUBLE m)


178 
param_init_number& param_init_number::operator=(const double m)


179  179 
{ 
180  180 
this>dvariable::operator=(m); 
181  181 
return *this; 
...  ...  
187  187 
return *this; 
188  188 
} 
189  189  
190 
param_init_bounded_number& param_init_bounded_number::operator = (CGNU_DOUBLE m)


190 
param_init_bounded_number& param_init_bounded_number::operator=(const double m)


191  191 
{ 
192  192 
this>dvariable::operator=(m); 
193  193 
return *this; 
...  ...  
368  368 
dmatrix::operator=(m); 
369  369 
return *this; 
370  370 
} 
371 
named_dmatrix& named_dmatrix::operator=(CGNU_DOUBLE m)


371 
named_dmatrix& named_dmatrix::operator=(const double m)


372  372 
{ 
373  373 
dmatrix::operator=(m); 
374  374 
return *this; 
...  ...  
380  380 
return *this; 
381  381 
} 
382  382  
383 
param_stddev_number& param_stddev_number::operator = (CGNU_DOUBLE m)


383 
param_stddev_number& param_stddev_number::operator=(const double m)


384  384 
{ 
385  385 
prevariable::operator=(m); 
386  386 
return *this; 
387  387 
} 
388  388  
389 
named_dvariable& named_dvariable::operator = (CGNU_DOUBLE m)


389 
named_dvariable& named_dvariable::operator=(const double m)


390  390 
{ 
391  391 
prevariable::operator=(m); 
392  392 
return *this; 
Also available in: Unified diff