bool IterativeMethod::Solve(Type type,Vector& x0,int& maxIters,Real& tol) const
{
bool valid=false;
switch(type) {
case Jacobi: valid=IsValid_Jacobi(); break;
case GaussSeidel: valid=IsValid_GaussSeidel(); break;
case SOR: valid=IsValid_SOR(); break;
default: AssertNotReached();
}
if(!valid) {
cout<<"Warning: matrix in IterativeMethod::Solve() won't guarantee convergence"<<endl;
}
Vector r;
for(int i=0;i<maxIters;i++) {
switch(type) {
case Jacobi: Iterate_Jacobi(x0); break;
case GaussSeidel: Iterate_GaussSeidel(x0); break;
case SOR: Iterate_SOR(x0); break;
default: AssertNotReached();
}
//calculate residual
r.setNegative(b); A.madd(x0,r);
Real rnorm=r.norm();
if(rnorm <= Sqr(tol)) {
tol = rnorm;
maxIters = i;
return true;
}
}
return false;
}
/**
* mio_puts:
* @mio: A #MIO object
* @s: The string to write
*
* Writes a string to a #MIO object. This function behaves the same as fputs().
*
* Returns: A non-negative integer on success or %EOF on failure.
*/
int mio_puts (MIO *mio, const char *s)
{
if (mio->type == MIO_TYPE_FILE)
return fputs (s, mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
int rv = EOF;
size_t len;
len = strlen (s);
if (mem_try_ensure_space (mio, len))
{
memcpy (&mio->impl.mem.buf[mio->impl.mem.pos], s, len);
mio->impl.mem.pos += len;
rv = 1;
}
return rv;
}
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_getc:
* @mio: A #MIO object
*
* Gets the current character from a #MIO stream. This function behaves the same
* as fgetc().
*
* Returns: The read character as a #int, or %EOF on error.
*/
int mio_getc (MIO *mio)
{
if (mio->type == MIO_TYPE_FILE)
return fgetc (mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
int rv = EOF;
if (mio->impl.mem.ungetch != EOF)
{
rv = mio->impl.mem.ungetch;
mio->impl.mem.ungetch = EOF;
mio->impl.mem.pos++;
}
else if (mio->impl.mem.pos < mio->impl.mem.size)
{
rv = mio->impl.mem.buf[mio->impl.mem.pos];
mio->impl.mem.pos++;
}
else
mio->impl.mem.eof = TRUE;
return rv;
}
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_tell:
* @mio: A #MIO object
*
* Gets the current cursor position of a #MIO stream. This function behaves the
* same as ftell().
*
* Returns: The current offset from the start of the stream, or -1 or error, in
* which case errno is set to indicate the error.
*/
long mio_tell (MIO *mio)
{
if (mio->type == MIO_TYPE_FILE)
return ftell (mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
long rv = -1;
if (mio->impl.mem.pos > LONG_MAX)
{
#ifdef EOVERFLOW
errno = EOVERFLOW;
#endif
}
else
rv = (long)mio->impl.mem.pos;
return rv;
}
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_write:
* @mio: A #MIO object
* @ptr: Pointer to the memory to write on the stream
* @size: Size of each block to write
* @nmemb: Number of block to write
*
* Writes raw data to a #MIO stream. This function behaves the same as fwrite().
*
* Returns: The number of blocks actually written to the stream. This might be
* smaller than the requested count if a write error occurs.
*/
size_t mio_write (MIO *mio,
const void *ptr,
size_t size,
size_t nmemb)
{
if (mio->type == MIO_TYPE_FILE)
return fwrite (ptr, size, nmemb, mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
size_t n_written = 0;
if (size != 0 && nmemb != 0)
{
if (mem_try_ensure_space (mio, size * nmemb))
{
memcpy (&mio->impl.mem.buf[mio->impl.mem.pos], ptr, size * nmemb);
mio->impl.mem.pos += size * nmemb;
n_written = nmemb;
}
}
return n_written;
}
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_error:
* @mio: A #MIO object
*
* Checks whether the error indicator of a #MIO stream is set. This function
* behaves the same as ferror().
*
* Returns: A non-null value if the stream have an error set, 0 otherwise.
*/
int mio_error (MIO *mio)
{
if (mio->type == MIO_TYPE_FILE)
return ferror (mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
return mio->impl.mem.error != FALSE;
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_clearerr:
* @mio: A #MIO object
*
* Clears the error and end-of-stream indicators of a #MIO stream. This function
* behaves the same as clearerr().
*/
void mio_clearerr (MIO *mio)
{
if (mio->type == MIO_TYPE_FILE)
clearerr (mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
mio->impl.mem.error = FALSE;
mio->impl.mem.eof = FALSE;
}
else
AssertNotReached ();
}
virtual int AddMilestone(const Config& q) {
if(qStart.n == 0) {
qStart = q;
return 0;
}
else if(qGoal.n == 0) {
qGoal = q;
planner.Init(qStart,qGoal);
return 1;
}
AssertNotReached();
return -1;
}
/**
* mio_vprintf:
* @mio: A #MIO object
* @format: A printf fomrat string
* @ap: The variadic argument list for the format
*
* Writes a formatted string into a #MIO stream. This function behaves the same
* as vfprintf().
*
* Returns: The number of bytes written in the stream, or a negative value on
* failure.
*/
int mio_vprintf (MIO *mio, const char *format, va_list ap)
{
if (mio->type == MIO_TYPE_FILE)
return vfprintf (mio->impl.file.fp, format, ap);
else if (mio->type == MIO_TYPE_MEMORY)
{
int rv = -1;
size_t n;
size_t old_pos;
size_t old_size;
va_list ap_copy;
char c;
old_pos = mio->impl.mem.pos;
old_size = mio->impl.mem.size;
va_copy (ap_copy, ap);
/* compute the size we will need into the buffer */
n = vsnprintf (&c, 1, format, ap_copy);
va_end (ap_copy);
if (mem_try_ensure_space (mio, n))
{
unsigned char c;
/* backup character at n+1 that will be overwritten by a \0 ... */
c = mio->impl.mem.buf[mio->impl.mem.pos + (n - 1)];
rv = vsprintf ((char *)&mio->impl.mem.buf[mio->impl.mem.pos], format, ap);
/* ...and restore it */
mio->impl.mem.buf[mio->impl.mem.pos + (n - 1)] = c;
if (rv >= 0 && (size_t)rv == (n - 1))
{
/* re-compute the actual size since we might have allocated one byte
* more than needed */
mio->impl.mem.size = MAX (old_size, old_pos + (unsigned int)rv);
mio->impl.mem.pos += (unsigned int)rv;
}
else
{
mio->impl.mem.size = old_size;
rv = -1;
}
}
return rv;
}
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_rewind:
* @mio: A #MIO object
*
* Resets the cursor position to 0, and also the end-of-stream and the error
* indicators of a #MIO stream.
* See also mio_seek() and mio_clearerr().
*/
void mio_rewind (MIO *mio)
{
if (mio->type == MIO_TYPE_FILE)
rewind (mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
mio->impl.mem.pos = 0;
mio->impl.mem.ungetch = EOF;
mio->impl.mem.eof = FALSE;
mio->impl.mem.error = FALSE;
}
else
AssertNotReached ();
}
/**
* mio_read:
* @mio: A #MIO object
* @ptr: Pointer to the memory to fill with the read data
* @size: Size of each block to read
* @nmemb: Number o blocks to read
*
* Reads raw data from a #MIO stream. This function behave the same as fread().
*
* Returns: The number of actually read blocks. If an error occurs or if the
* end of the stream is reached, the return value may be smaller than
* the requested block count, or even 0. This function doesn't
* distinguish between end-of-stream and an error, you should then use
* mio_eof() and mio_error() to determine which occurred.
*/
size_t mio_read (MIO *mio,
void *ptr_,
size_t size,
size_t nmemb)
{
if (mio->type == MIO_TYPE_FILE)
return fread (ptr_, size, nmemb, mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
size_t n_read = 0;
if (size != 0 && nmemb != 0)
{
size_t size_avail = mio->impl.mem.size - mio->impl.mem.pos;
size_t copy_bytes = size * nmemb;
unsigned char *ptr = ptr_;
if (size_avail < copy_bytes)
copy_bytes = size_avail;
if (copy_bytes > 0)
{
n_read = copy_bytes / size;
if (mio->impl.mem.ungetch != EOF)
{
*ptr = (unsigned char) mio->impl.mem.ungetch;
mio->impl.mem.ungetch = EOF;
copy_bytes--;
mio->impl.mem.pos++;
ptr++;
}
memcpy (ptr, &mio->impl.mem.buf[mio->impl.mem.pos], copy_bytes);
mio->impl.mem.pos += copy_bytes;
}
if (mio->impl.mem.pos >= mio->impl.mem.size)
mio->impl.mem.eof = TRUE;
}
return n_read;
}
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_gets:
* @mio: A #MIO object
* @s: A string to fill with the read data
* @size: The maximum number of bytes to read
*
* Reads a string from a #MIO stream, stopping after the first new-line
* character or at the end of the stream. This function behaves the same as
* fgets().
*
* Returns: @s on success, %NULL otherwise.
*/
char *mio_gets (MIO *mio, char *s, size_t size)
{
if (mio->type == MIO_TYPE_FILE)
return fgets (s, (int)size, mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
char *rv = NULL;
if (size > 0)
{
size_t i = 0;
if (mio->impl.mem.ungetch != EOF)
{
s[i] = (char)mio->impl.mem.ungetch;
mio->impl.mem.ungetch = EOF;
mio->impl.mem.pos++;
i++;
}
for (; mio->impl.mem.pos < mio->impl.mem.size && i < (size - 1); i++)
{
s[i] = (char)mio->impl.mem.buf[mio->impl.mem.pos];
mio->impl.mem.pos++;
if (s[i] == '\n')
{
i++;
break;
}
}
if (i > 0)
{
s[i] = 0;
rv = s;
}
if (mio->impl.mem.pos >= mio->impl.mem.size)
mio->impl.mem.eof = TRUE;
}
return rv;
}
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_free:
* @mio: A #MIO object
*
* Decrements the reference counter of a #MIO and destroys the #MIO
* object if its counter becomes 0.
*
* Returns: Error code obtained from the registered MIOFCloseFunc or 0 on success.
*/
int mio_free (MIO *mio)
{
int rv = 0;
if (mio)
{
if (--mio->refcount)
return 0;
if (mio->udata.d && mio->udata.f)
mio->udata.f (mio->udata.d);
if (mio->type == MIO_TYPE_FILE)
{
if (mio->impl.file.close_func)
rv = mio->impl.file.close_func (mio->impl.file.fp);
mio->impl.file.close_func = NULL;
mio->impl.file.fp = NULL;
}
else if (mio->type == MIO_TYPE_MEMORY)
{
if (mio->impl.mem.free_func)
mio->impl.mem.free_func (mio->impl.mem.buf);
mio->impl.mem.buf = NULL;
mio->impl.mem.pos = 0;
mio->impl.mem.size = 0;
mio->impl.mem.allocated_size = 0;
mio->impl.mem.realloc_func = NULL;
mio->impl.mem.free_func = NULL;
mio->impl.mem.eof = FALSE;
mio->impl.mem.error = FALSE;
}
else
AssertNotReached ();
eFree (mio);
}
return rv;
}
/**
* mio_ungetc:
* @mio: A #MIO object
* @ch: Character to put back in the stream
*
* Puts a character back in a #MIO stream. This function behaves the sames as
* ungetc().
*
* <warning><para>It is only guaranteed that one character can be but back at a
* time, even if the implementation may allow more.</para></warning>
* <warning><para>Using this function while the stream cursor is at offset 0 is
* not guaranteed to function properly. As the C99 standard says, it is "an
* obsolescent feature".</para></warning>
*
* Returns: The character put back, or %EOF on error.
*/
int mio_ungetc (MIO *mio, int ch)
{
if (mio->type == MIO_TYPE_FILE)
return ungetc (ch, mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
int rv = EOF;
if (ch != EOF && mio->impl.mem.ungetch == EOF)
{
rv = mio->impl.mem.ungetch = ch;
mio->impl.mem.pos--;
mio->impl.mem.eof = FALSE;
}
return rv;
}
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_putc:
* @mio: A #MIO object
* @c: The character to write
*
* Writes a character to a #MIO stream. This function behaves the same as
* fputc().
*
* Returns: The written wharacter, or %EOF on error.
*/
int mio_putc (MIO *mio, int c)
{
if (mio->type == MIO_TYPE_FILE)
return fputc (c, mio->impl.file.fp);
else if (mio->type == MIO_TYPE_MEMORY)
{
int rv = EOF;
if (mem_try_ensure_space (mio, 1))
{
mio->impl.mem.buf[mio->impl.mem.pos] = (unsigned char)c;
mio->impl.mem.pos++;
rv = (int)((unsigned char)c);
}
return rv;
}
else
{
AssertNotReached ();
return 0;
}
}
/**
* mio_setpos:
* @mio: A #MIO object
* @pos: (in): A #MIOPos object filled-in by a previous call of mio_getpos() on
* the same stream
*
* Restores the position and state indicators of a #MIO stream previously saved
* by mio_getpos().
*
* <warning><para>The #MIOPos object must have been initialized by a previous
* call to mio_getpos() on the same stream.</para></warning>
*
* Returns: 0 on success, -1 otherwise, in which case errno is set to indicate
* the error.
*/
int mio_setpos (MIO *mio, MIOPos *pos)
{
int rv = -1;
#ifdef MIO_DEBUG
if (pos->tag != mio)
{
g_critical ("mio_setpos((MIO*)%p, (MIOPos*)%p): "
"Given MIOPos was not set by a previous call to mio_getpos() "
"on the same MIO object, which means there is a bug in "
"someone's code.",
(void *)mio, (void *)pos);
errno = EINVAL;
return -1;
}
#endif /* MIO_DEBUG */
if (mio->type == MIO_TYPE_FILE)
rv = fsetpos (mio->impl.file.fp, &pos->impl.file);
else if (mio->type == MIO_TYPE_MEMORY)
{
rv = -1;
if (pos->impl.mem > mio->impl.mem.size)
errno = EINVAL;
else
{
mio->impl.mem.ungetch = EOF;
mio->impl.mem.pos = pos->impl.mem;
rv = 0;
}
}
else
AssertNotReached ();
return rv;
}
static json_t* escapeFieldValue (const tagEntryInfo * tag, fieldType ftype, bool returnEmptyStringAsNoValue)
{
const char *str = renderFieldEscaped (jsonWriter.type, ftype, tag, NO_PARSER_FIELD, NULL);
if (str)
{
unsigned int dt = getFieldDataType(ftype);
if (dt & FIELDTYPE_STRING)
{
if (dt & FIELDTYPE_BOOL && str[0] == '\0')
return json_false();
else
return json_string (str);
}
else if (dt & FIELDTYPE_INTEGER)
{
long tmp;
if (strToLong (str, 10, &tmp))
return json_integer (tmp);
else
return NULL;
}
else if (dt & FIELDTYPE_BOOL)
{
/* TODO: This must be fixed when new boolean field is added.
Currently only `file:' field use this. */
return json_boolean (strcmp ("-", str)); /* "-" -> false */
}
AssertNotReached ();
return NULL;
}
else if (returnEmptyStringAsNoValue)
return json_false();
else
return NULL;
}
/**
* mio_getpos:
* @mio: A #MIO stream
* @pos: (out): A #MIOPos object to fill-in
*
* Stores the current position (and maybe other informations about the stream
* state) of a #MIO stream in order to restore it later with mio_setpos(). This
* function behaves the same as fgetpos().
*
* Returns: 0 on success, -1 otherwise, in which case errno is set to indicate
* the error.
*/
int mio_getpos (MIO *mio, MIOPos *pos)
{
int rv = -1;
pos->type = mio->type;
if (mio->type == MIO_TYPE_FILE)
rv = fgetpos (mio->impl.file.fp, &pos->impl.file);
else if (mio->type == MIO_TYPE_MEMORY)
{
rv = -1;
if (mio->impl.mem.pos == (size_t)-1)
{
/* this happens if ungetc() was called at the start of the stream */
#ifdef EIO
errno = EIO;
#endif
}
else
{
pos->impl.mem = mio->impl.mem.pos;
rv = 0;
}
}
else
AssertNotReached();
#ifdef MIO_DEBUG
if (rv != -1)
{
pos->tag = mio;
}
#endif /* MIO_DEBUG */
return rv;
}
int installSyscallFilter (void)
{
AssertNotReached ();
return -1;
}
/**
* mio_seek:
* @mio: A #MIO object
* @offset: Offset of the new place, from @whence
* @whence: Move origin. SEEK_SET moves relative to the start of the stream,
* SEEK_CUR from the current position and SEEK_SET from the end of the
* stream.
*
* Sets the curosr position on a #MIO stream. This functions behaves the same as
* fseek(). See also mio_tell() and mio_setpos().
*
* Returns: 0 on success, -1 otherwise, in which case errno should be set to
* indicate the error.
*/
int mio_seek (MIO *mio, long offset, int whence)
{
if (mio->type == MIO_TYPE_FILE)
return fseek (mio->impl.file.fp, offset, whence);
else if (mio->type == MIO_TYPE_MEMORY)
{
/* FIXME: should we support seeking out of bounds like lseek() seems to do? */
int rv = -1;
switch (whence)
{
case SEEK_SET:
if (offset < 0 || (size_t)offset > mio->impl.mem.size)
errno = EINVAL;
else
{
mio->impl.mem.pos = (size_t)offset;
rv = 0;
}
break;
case SEEK_CUR:
if ((offset < 0 && (size_t)-offset > mio->impl.mem.pos) ||
mio->impl.mem.pos + (size_t)offset > mio->impl.mem.size)
{
errno = EINVAL;
}
else
{
mio->impl.mem.pos = (size_t)(mio->impl.mem.pos + offset);
rv = 0;
}
break;
case SEEK_END:
if (offset > 0 || (size_t)-offset > mio->impl.mem.size)
errno = EINVAL;
else
{
mio->impl.mem.pos = mio->impl.mem.size - (size_t)-offset;
rv = 0;
}
break;
default:
errno = EINVAL;
}
if (rv == 0)
{
mio->impl.mem.eof = FALSE;
mio->impl.mem.ungetch = EOF;
}
return rv;
}
else
{
AssertNotReached ();
return 0;
}
}
template<> Complex SparseVectorTemplate<Complex>::maxElement(int* index) const
{
cerr<<"Incomplete"<<endl;
AssertNotReached();
return Zero;
}
