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; }