main()
{
FILE * stream;
set_s(0,"Linux!");
set_s(1,"FreeBSD!");
set_s(2,"Windows2000.");
stream=fopen("/tmp/fwrite","w");
fwrite(s,sizeof(struct test),nmemb,stream);
fclose(stream);
}
int main()
{
FILE * fp; /*定义文件变量指针*/
set_s(0,"张三",12345);
set_s(1,"李四",200);
set_s(2,"王五",50000);
fp=fopen("4-12file","a+"); /*打开(创建)文件*/
fwrite(s,sizeof(struct test),nmemb,fp);/*调用fwite函数把块信息写入文件*/
fclose(fp);
return 0; /*关闭文件流*/
}
/*!
Link from user_atomic to forward sparse Jacobian
\copydetails atomic_base::rev_sparse_hes
*/
virtual bool rev_sparse_hes(
const vector<bool>& vx ,
const vector<bool>& s ,
vector<bool>& t ,
size_t q ,
const vector< std::set<size_t> >& r ,
const vector< std::set<size_t> >& u ,
vector< std::set<size_t> >& v )
{ size_t n = v.size();
size_t m = u.size();
CPPAD_ASSERT_UNKNOWN( r.size() == v.size() );
CPPAD_ASSERT_UNKNOWN( s.size() == m );
CPPAD_ASSERT_UNKNOWN( t.size() == n );
bool ok = true;
bool transpose = true;
std::set<size_t>::const_iterator itr;
// compute sparsity pattern for T(x) = S(x) * f'(x)
t = f_.RevSparseJac(1, s);
# ifndef NDEBUG
for(size_t j = 0; j < n; j++)
CPPAD_ASSERT_UNKNOWN( vx[j] || ! t[j] )
# endif
// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
// U(x) = g''(y) * f'(x) * R
// S(x) = g'(y)
// compute sparsity pattern for A(x) = f'(x)^T * U(x)
vector< std::set<size_t> > a(n);
a = f_.RevSparseJac(q, u, transpose);
// set version of s
vector< std::set<size_t> > set_s(1);
CPPAD_ASSERT_UNKNOWN( set_s[0].empty() );
size_t i;
for(i = 0; i < m; i++)
if( s[i] )
set_s[0].insert(i);
// compute sparsity pattern for H(x) = (S(x) * F)''(x) * R
// (store it in v)
f_.ForSparseJac(q, r);
v = f_.RevSparseHes(q, set_s, transpose);
// compute sparsity pattern for V(x) = A(x) + H(x)
for(i = 0; i < n; i++)
{ for(itr = a[i].begin(); itr != a[i].end(); itr++)
{ size_t j = *itr;
CPPAD_ASSERT_UNKNOWN( j < q );
v[i].insert(j);
}
}
// no longer need the forward mode sparsity pattern
// (have to reconstruct them every time)
f_.size_forward_set(0);
return ok;
}
obj* String(char* value) {
obj* self = Object();
set_s(self, "value", value);
set_d(self, "length", strlen(value) + 1);
set_d(self, "capacity", strlen(value) + 1);
bind_c(self, "char at", char_at);
bind(self, "append", append);
return self;
}
obj* FormattedString(char* format, ...) {
va_list args;
va_start(args, format);
int size_needed = vsnprintf(NULL, 0, format, args);
char* value = calloc(size_needed + 1, sizeof(char));
vsnprintf(value, size_needed, format, args);
obj* self = Object();
set_s(self, "value", value);
free(value);
set_d(self, "length", size_needed - 1);
set_d(self, "capacity", size_needed);
bind_c(self, "char at", char_at);
bind(self, "append", append);
return self;
}
void append(obj* self, va_list* args) {
char* part_two = va_arg(*args, char*);
char* part_one = get_s(self, "value");
char* joined;
int part_one_length = strlen(part_one);
int part_two_length = strlen(part_two);
int capacity = get_d(self, "capacity");
if (part_one_length + part_two_length + 1 > capacity) {
int new_capacity = (capacity * 2) + part_two_length + 1;
joined = calloc(new_capacity, sizeof(char));
assert(joined);
strncpy(joined, part_one, part_one_length);
set_d(self, "capacity", new_capacity);
}
strncat(joined, part_two, part_two_length);
set_s(self, "value", joined);
set_d(self, "length", part_one_length + part_two_length);
free(joined);
}
