Fourti2IOHandler.cpp
Go to the documentation of this file.
/* Frobby: Software for monomial ideal computations.
Copyright (C) 2007 Bjarke Hammersholt Roune (www.broune.com)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see http://www.gnu.org/licenses/.
*/
#include "stdinc.h"
#include "Fourti2IOHandler.h"
#include "Scanner.h"
#include "BigIdeal.h"
#include "Term.h"
#include "TermTranslator.h"
#include "BigPolynomial.h"
#include "BigTermConsumer.h"
#include "DataType.h"
#include "IdealConsolidator.h"
#include "PolynomialConsolidator.h"
#include "SatBinomIdeal.h"
#include "SatBinomConsumer.h"
#include "IdealWriter.h"
#include "PolyWriter.h"
#include "error.h"
#include "display.h"
#include "InputConsumer.h"
namespace IO {
namespace Fourti2 {
void writeRing(const VarNames& names, FILE* out);
void writeRingWithoutHeader(const VarNames& names, FILE* out);
void readTerm(Scanner& in, InputConsumer& consumer);
void readRing(Scanner& in, VarNames& names);
void readRing(Scanner& in, VarNames& names, size_t varCount);
void writeTerm(const vector<mpz_class>& term, FILE* out);
void writeTerm(const Term& term,
const TermTranslator& translator,
FILE* out);
void readIdeal(Scanner& in,
InputConsumer& consumer,
size_t generatorCount,
size_t varCount);
void readSatBinomIdeal(Scanner& in,
SatBinomConsumer& consumer,
size_t generatorCount,
size_t varCount);
void display4ti2Warning();
}
namespace F = Fourti2;
class Fourti2IdealWriter : public IdealWriter {
public:
Fourti2IdealWriter(FILE* out): IdealWriter(out) {
}
private:
virtual void doWriteHeader(bool first) {
INTERNAL_ERROR_UNIMPLEMENTED();
}
virtual void doWriteHeader(bool first, size_t generatorCount) {
fprintf(getFile(), "%lu %lu\n",
(unsigned long)generatorCount,
(unsigned long)getNames().getVarCount());
}
virtual void doWriteTerm(const Term& term,
const TermTranslator& translator,
bool first) {
F::writeTerm(term, translator, getFile());
}
virtual void doWriteTerm(const vector<mpz_class>& term, bool first) {
F::writeTerm(term, getFile());
}
virtual void doWriteFooter(bool wasZeroIdeal) {
if (!getNames().namesAreDefault())
F::writeRingWithoutHeader(getNames(), getFile());
}
virtual void doWriteEmptyList() {
F::writeRing(getNames(), getFile());
}
};
class Fourti2PolyWriter : public PolyWriter {
public:
Fourti2PolyWriter(FILE* out): PolyWriter(out) {
}
private:
virtual void doWriteHeader() {
INTERNAL_ERROR_UNIMPLEMENTED();
}
virtual void doWriteHeader(size_t termCount) {
fprintf(getFile(), "%lu %lu\n",
(unsigned long)termCount,
(unsigned long)getNames().getVarCount() + 1);
}
virtual void doWriteTerm(const mpz_class& coef,
const Term& term,
const TermTranslator& translator,
bool firstGenerator) {
ASSERT(term.getVarCount() == translator.getVarCount());
mpz_out_str(getFile(), 10, coef.get_mpz_t());
if (term.getVarCount() > 0) {
fputc(' ', getFile());
F::writeTerm(term, translator, getFile());
} else
fputc('\n', getFile());
}
virtual void doWriteTerm(const mpz_class& coef,
const vector<mpz_class>& term,
bool firstGenerator) {
ASSERT(term.size() == getNames().getVarCount());
mpz_out_str(getFile(), 10, coef.get_mpz_t());
if (!term.empty()) {
fputc(' ', getFile());
F::writeTerm(term, getFile());
} else
fputc('\n', getFile());
}
virtual void doWriteFooter(bool wasZero) {
fputs("(coefficient)", getFile());
if (!getNames().namesAreDefault())
F::writeRingWithoutHeader(getNames(), getFile());
else
fputc('\n', getFile());
};
};
Fourti2IOHandler::Fourti2IOHandler():
IOHandlerImpl(staticGetName(),
"Format used by the software package 4ti2.") {
registerInput(DataType::getMonomialIdealType());
registerInput(DataType::getMonomialIdealListType());
registerInput(DataType::getPolynomialType());
registerInput(DataType::getSatBinomIdealType());
registerOutput(DataType::getMonomialIdealType());
registerOutput(DataType::getMonomialIdealListType());
registerOutput(DataType::getPolynomialType());
}
const char* Fourti2IOHandler::staticGetName() {
return "4ti2";
}
BigTermConsumer* Fourti2IOHandler::doCreateIdealWriter(FILE* out) {
F::display4ti2Warning();
unique_ptr<BigTermConsumer> writer(new Fourti2IdealWriter(out));
return new IdealConsolidator(std::move(writer));
}
CoefBigTermConsumer* Fourti2IOHandler::doCreatePolynomialWriter(FILE* out) {
F::display4ti2Warning();
unique_ptr<CoefBigTermConsumer> writer(new Fourti2PolyWriter(out));
return new PolynomialConsolidator(std::move(writer));
}
void Fourti2IOHandler::doWriteTerm(const vector<mpz_class>& term,
const VarNames& names,
FILE* out) {
if (term.empty()) {
// Otherwise we will print nothing, which would be OK inside an
// ideal since then it is possible to see what happened from the
// number of generators and variables. We do not have that
// information here, so we have to print something.
fputs("_fourtitwo_identity", out);
}
F::writeTerm(term, out);
}
void Fourti2IOHandler::doReadTerm(Scanner& in, InputConsumer& consumer) {
F::readTerm(in, consumer);
}
void Fourti2IOHandler::doReadIdeal(Scanner& in, InputConsumer& consumer) {
size_t generatorCount;
in.readSizeT(generatorCount);
size_t varCount;
in.readSizeT(varCount);
F::readIdeal(in, consumer, generatorCount, varCount);
}
void Fourti2IOHandler::doReadIdeals(Scanner& in, InputConsumer& consumer) {
// An empty list is just a ring by itself, and this has a special
// syntax. So we first decipher whether we are looking at a ring or
// an ideal. At the point where we can tell that it is an ideal, we
// have already read part of the ideal, so we have to do something
// to pass the read information on to the code for reading the rest
// of the ideal.
size_t generatorCount;
in.readSizeT(generatorCount);
if (generatorCount == 42 && in.peekIdentifier()) {
in.expect("ring");
VarNames names;
F::readRing(in, names);
consumer.consumeRing(names);
in.expectEOF();
return;
}
size_t varCount;
in.readSizeT(varCount);
F::readIdeal(in, consumer, generatorCount, varCount);
while (hasMoreInput(in))
doReadIdeal(in, consumer);
}
void Fourti2IOHandler::doReadPolynomial(Scanner& in,
CoefBigTermConsumer& consumer) {
size_t generatorCount;
size_t varCount;
in.readSizeT(generatorCount);
in.readSizeT(varCount);
if (varCount == 0)
reportError
("A polynomial has at least one column in the matrix,"
"but this matrix has no columns.");
// The first column is the coefficient and so does not represent a
// variable.
--varCount;
BigPolynomial polynomial((VarNames(varCount)));
for (size_t t = 0; t < generatorCount; ++t) {
// Read a term
polynomial.newLastTerm();
in.readInteger(polynomial.getLastCoef());
vector<mpz_class>& term = polynomial.getLastTerm();
for (size_t var = 0; var < varCount; ++var) {
ASSERT(var < term.size());
in.readIntegerAndNegativeAsZero(term[var]);
}
}
if (!in.match('(')) {
// This expect will fail which improves the error message compared
// to just expect('(').
in.expect("(coefficient)");
}
in.expect("coefficient");
in.expect(')');
if (in.peekIdentifier()) {
VarNames names;
for (size_t var = 0; var < varCount; ++var)
names.addVar(in.readIdentifier());
polynomial.renameVars(names);
}
consumer.consume(polynomial);
}
void Fourti2IOHandler::doReadSatBinomIdeal(Scanner& in,
SatBinomConsumer& consumer) {
size_t generatorCount;
in.readSizeT(generatorCount);
size_t varCount;
in.readSizeT(varCount);
F::readSatBinomIdeal(in, consumer, generatorCount, varCount);
}
void F::writeRing(const VarNames& names, FILE* out) {
fputs("42 ring\n", out);
writeRingWithoutHeader(names, out);
}
void F::writeRingWithoutHeader(const VarNames& names, FILE* out) {
if (names.getVarCount() == 0)
return;
fputc(' ', out);
for (size_t var = 0; var < names.getVarCount(); ++var) {
if (var > 0)
fputc(' ', out);
fputs(names.getName(var).c_str(), out);
}
fputc('\n', out);
}
void F::readTerm(Scanner& in, InputConsumer& consumer) {
consumer.beginTerm();
const size_t varCount = consumer.getRing().getVarCount();
if (varCount == 0)
in.expect("_fourtitwo_identity");
else {
for (size_t var = 0; var < varCount; ++var) {
if (in.match('-'))
in.expectIntegerNoSign();
else
consumer.consumeVarExponent(var, in);
}
}
consumer.endTerm();
}
void F::readRing(Scanner& in, VarNames& names) {
names.clear();
while (in.peekIdentifier())
names.addVarSyntaxCheckUnique(in, in.readIdentifier());
}
void F::readRing(Scanner& in, VarNames& names, size_t varCount) {
names.clear();
for (size_t var = 0; var < varCount; ++var)
names.addVarSyntaxCheckUnique(in, in.readIdentifier());
}
void F::writeTerm(const vector<mpz_class>& term, FILE* out) {
size_t varCount = term.size();
for (size_t var = 0; var < varCount; ++var) {
fputc(' ', out);
mpz_out_str(out, 10, term[var].get_mpz_t());
}
if (varCount != 0)
fputc('\n', out);
}
void F::writeTerm(const Term& term,
const TermTranslator& translator,
FILE* out) {
ASSERT(term.getVarCount() == translator.getVarCount());
size_t varCount = term.getVarCount();
for (size_t var = 0; var < varCount; ++var) {
fputc(' ', out);
const char* exp = translator.getExponentString(var, term[var]);
if (exp == 0)
exp = "0";
fputs(exp, out);
}
if (varCount != 0)
fputc('\n', out);
}
void F::readIdeal(Scanner& in,
InputConsumer& consumer,
size_t generatorCount,
size_t varCount) {
consumer.consumeRing(VarNames(varCount));
consumer.beginIdeal();
if (varCount == 0) {
for (size_t t = 0; t < generatorCount; ++t) {
consumer.beginTerm();
consumer.endTerm();
}
} else {
for (size_t t = 0; t < generatorCount; ++t)
F::readTerm(in, consumer);
}
if (in.peekIdentifier()) {
VarNames names;
F::readRing(in, names, varCount);
consumer.consumeRing(names);
}
consumer.endIdeal();
}
void F::readSatBinomIdeal(Scanner& in,
SatBinomConsumer& consumer,
size_t generatorCount,
size_t varCount) {
// We have to read the entire ideal before we can tell whether there is
// a ring associated to it, so we have to store the ideal here until
// that time.
SatBinomIdeal ideal((VarNames(varCount)));
ideal.reserve(generatorCount);
for (size_t t = 0; t < generatorCount; ++t) {
// Read a term
ideal.newLastTerm();
vector<mpz_class>& binom = ideal.getLastBinomRef();
for (size_t var = 0; var < varCount; ++var)
in.readInteger(binom[var]);
}
if (in.peekIdentifier()) {
VarNames names;
F::readRing(in, names, varCount);
ideal.renameVars(names);
}
consumer.consume(ideal);
}
void F::display4ti2Warning() {
string msg = "Using the format ";
msg += Fourti2IOHandler::staticGetName();
msg += " makes it necessary to store all of the output in "
"memory before writing it out. This increases "
"memory consumption and decreases performance.";
displayNote(msg);
}
}
BigIdeal.h
BigPolynomial.h
BigTermConsumer.h
DataType.h
Fourti2IOHandler.h
IdealConsolidator.h
IdealWriter.h
InputConsumer.h
PolyWriter.h
PolynomialConsolidator.h
SatBinomConsumer.h
SatBinomIdeal.h
Scanner.h
TermTranslator.h
Term.h
BigPolynomial
Definition BigPolynomial.h:27
BigPolynomial::getLastCoef
mpz_class & getLastCoef()
Definition BigPolynomial.cpp:89
BigPolynomial::newLastTerm
void newLastTerm()
Definition BigPolynomial.cpp:78
BigPolynomial::renameVars
void renameVars(const VarNames &names)
Definition BigPolynomial.cpp:95
BigPolynomial::getLastTerm
vector< mpz_class > & getLastTerm()
Definition BigPolynomial.cpp:83
BigTermConsumer
Definition BigTermConsumer.h:29
CoefBigTermConsumer
Definition CoefBigTermConsumer.h:29
CoefBigTermConsumer::consume
virtual void consume(const mpz_class &coef, const Term &term)
Definition CoefBigTermConsumer.cpp:25
DataType::getSatBinomIdealType
static const DataType & getSatBinomIdealType()
Returns the one and only instance for saturated binomial ideals.
Definition DataType.cpp:59
DataType::getMonomialIdealListType
static const DataType & getMonomialIdealListType()
Returns the one and only instance for monomial ideal lists.
Definition DataType.cpp:54
DataType::getMonomialIdealType
static const DataType & getMonomialIdealType()
Returns the one and only instance for monomial ideals.
Definition DataType.cpp:45
DataType::getPolynomialType
static const DataType & getPolynomialType()
Returns the one and only instance for polynomials.
Definition DataType.cpp:50
IOHandler::hasMoreInput
bool hasMoreInput(Scanner &in) const
Definition IOHandler.cpp:77
IO::Fourti2IOHandler::doCreateIdealWriter
virtual BigTermConsumer * doCreateIdealWriter(FILE *out)
Definition Fourti2IOHandler.cpp:166
IO::Fourti2IOHandler::doReadIdeal
virtual void doReadIdeal(Scanner &in, InputConsumer &consumer)
Definition Fourti2IOHandler.cpp:195
IO::Fourti2IOHandler::doWriteTerm
virtual void doWriteTerm(const vector< mpz_class > &term, const VarNames &names, FILE *out)
Definition Fourti2IOHandler.cpp:178
IO::Fourti2IOHandler::doReadSatBinomIdeal
virtual void doReadSatBinomIdeal(Scanner &in, SatBinomConsumer &consumer)
Definition Fourti2IOHandler.cpp:283
IO::Fourti2IOHandler::doReadPolynomial
virtual void doReadPolynomial(Scanner &in, CoefBigTermConsumer &consumer)
Definition Fourti2IOHandler.cpp:234
IO::Fourti2IOHandler::staticGetName
static const char * staticGetName()
Definition Fourti2IOHandler.cpp:162
IO::Fourti2IOHandler::doCreatePolynomialWriter
virtual CoefBigTermConsumer * doCreatePolynomialWriter(FILE *out)
Definition Fourti2IOHandler.cpp:172
IO::Fourti2IOHandler::doReadIdeals
virtual void doReadIdeals(Scanner &in, InputConsumer &consumer)
Definition Fourti2IOHandler.cpp:205
IO::Fourti2IOHandler::Fourti2IOHandler
Fourti2IOHandler()
Definition Fourti2IOHandler.cpp:150
IO::Fourti2IOHandler::doReadTerm
virtual void doReadTerm(Scanner &in, InputConsumer &consumer)
Definition Fourti2IOHandler.cpp:191
IO::Fourti2IdealWriter
Definition Fourti2IOHandler.cpp:60
IO::Fourti2IdealWriter::doWriteTerm
virtual void doWriteTerm(const vector< mpz_class > &term, bool first)
Definition Fourti2IOHandler.cpp:82
IO::Fourti2IdealWriter::doWriteTerm
virtual void doWriteTerm(const Term &term, const TermTranslator &translator, bool first)
Definition Fourti2IOHandler.cpp:76
IO::Fourti2IdealWriter::Fourti2IdealWriter
Fourti2IdealWriter(FILE *out)
Definition Fourti2IOHandler.cpp:62
IO::Fourti2IdealWriter::doWriteEmptyList
virtual void doWriteEmptyList()
Definition Fourti2IOHandler.cpp:91
IO::Fourti2IdealWriter::doWriteHeader
virtual void doWriteHeader(bool first, size_t generatorCount)
Definition Fourti2IOHandler.cpp:70
IO::Fourti2IdealWriter::doWriteFooter
virtual void doWriteFooter(bool wasZeroIdeal)
Definition Fourti2IOHandler.cpp:86
IO::Fourti2IdealWriter::doWriteHeader
virtual void doWriteHeader(bool first)
Definition Fourti2IOHandler.cpp:66
IO::Fourti2PolyWriter
Definition Fourti2IOHandler.cpp:96
IO::Fourti2PolyWriter::doWriteFooter
virtual void doWriteFooter(bool wasZero)
Definition Fourti2IOHandler.cpp:141
IO::Fourti2PolyWriter::doWriteTerm
virtual void doWriteTerm(const mpz_class &coef, const Term &term, const TermTranslator &translator, bool firstGenerator)
Definition Fourti2IOHandler.cpp:112
IO::Fourti2PolyWriter::doWriteHeader
virtual void doWriteHeader(size_t termCount)
Definition Fourti2IOHandler.cpp:106
IO::Fourti2PolyWriter::Fourti2PolyWriter
Fourti2PolyWriter(FILE *out)
Definition Fourti2IOHandler.cpp:98
IO::Fourti2PolyWriter::doWriteTerm
virtual void doWriteTerm(const mpz_class &coef, const vector< mpz_class > &term, bool firstGenerator)
Definition Fourti2IOHandler.cpp:127
IO::Fourti2PolyWriter::doWriteHeader
virtual void doWriteHeader()
Definition Fourti2IOHandler.cpp:102
IO::IOHandlerImpl::registerInput
void registerInput(const DataType &type)
Specify that input of the argument type is supported.
Definition IOHandlerImpl.cpp:60
IO::IOHandlerImpl::IOHandlerImpl
IOHandlerImpl(const char *formatName, const char *formatDescription)
Definition IOHandlerImpl.cpp:36
IO::IOHandlerImpl::registerOutput
void registerOutput(const DataType &type)
Specify that output of the argument type is supported.
Definition IOHandlerImpl.cpp:67
IO::IdealWriter::getFile
FILE * getFile()
Definition IdealWriter.h:43
IO::IdealWriter::IdealWriter
IdealWriter(FILE *out)
Definition IdealWriter.cpp:25
IO::IdealWriter::getNames
const VarNames & getNames()
Definition IdealWriter.h:44
IO::PolyWriter::PolyWriter
PolyWriter(FILE *out)
Definition PolyWriter.cpp:25
IO::PolyWriter::getFile
FILE * getFile()
Definition PolyWriter.h:40
IO::PolyWriter::getNames
const VarNames & getNames() const
Definition PolyWriter.h:41
IdealConsolidator
Definition IdealConsolidator.h:29
InputConsumer
Definition InputConsumer.h:30
InputConsumer::beginTerm
void beginTerm()
Start consuming a term.
Definition InputConsumer.cpp:62
InputConsumer::getRing
const VarNames & getRing() const
Returns the current ring.
Definition InputConsumer.h:91
InputConsumer::beginIdeal
void beginIdeal()
Start consuming an ideal.
Definition InputConsumer.cpp:50
InputConsumer::consumeRing
void consumeRing(const VarNames &names)
Definition InputConsumer.cpp:33
InputConsumer::consumeVarExponent
void consumeVarExponent(size_t var, Scanner &in)
Consumes var raised to an exponent read from in.
Definition InputConsumer.cpp:122
InputConsumer::endIdeal
void endIdeal()
Done reading an ideal.
Definition InputConsumer.cpp:191
InputConsumer::endTerm
void endTerm()
Done reading a term.
Definition InputConsumer.cpp:164
PolynomialConsolidator
Definition PolynomialConsolidator.h:25
SatBinomConsumer
Definition SatBinomConsumer.h:25
SatBinomConsumer::consume
virtual void consume(const vector< mpz_class > &term)=0
SatBinomIdeal
Represents a saturated binomial ideal.
Definition SatBinomIdeal.h:28
SatBinomIdeal::newLastTerm
void newLastTerm()
Definition SatBinomIdeal.cpp:135
SatBinomIdeal::getLastBinomRef
vector< mpz_class > & getLastBinomRef()
Definition SatBinomIdeal.cpp:129
SatBinomIdeal::renameVars
void renameVars(const VarNames &names)
Requires that names.getVarCount() equals getVarCount().
Definition SatBinomIdeal.cpp:76
SatBinomIdeal::reserve
void reserve(size_t size)
Definition SatBinomIdeal.cpp:91
Scanner
This class offers an input interface which is more convenient and for some purposes more efficient th...
Definition Scanner.h:50
Scanner::expectEOF
void expectEOF()
Require that there is no more input.
Definition Scanner.cpp:77
Scanner::readIntegerAndNegativeAsZero
void readIntegerAndNegativeAsZero(mpz_class &integer)
Read an integer and set it to zero if it is negative.
Definition Scanner.cpp:171
Scanner::expectIntegerNoSign
void expectIntegerNoSign()
Read an arbitrary-precision integer.
Definition Scanner.h:243
Scanner::expect
void expect(char expected)
Require the next character to be equal to expected.
Definition Scanner.h:231
Scanner::readIdentifier
const char * readIdentifier()
The returned string is only valid until the next method on this object gets called.
Definition Scanner.cpp:255
Scanner::peekIdentifier
bool peekIdentifier()
Skips whitespace and returns true if the next token is an identifier.
Definition Scanner.h:257
Scanner::readSizeT
void readSizeT(size_t &size)
Reads a size_t, where the representable range of that type determines when the number is too big.
Definition Scanner.cpp:205
Scanner::readInteger
void readInteger(mpz_class &integer)
Read an arbitrary-precision integer.
Definition Scanner.h:238
Scanner::match
bool match(char c)
Return true if the next character is c, and in that case skip past it.
Definition Scanner.h:215
TermTranslator
TermTranslator handles translation between terms whose exponents are infinite precision integers and ...
Definition TermTranslator.h:41
TermTranslator::getVarCount
size_t getVarCount() const
Definition TermTranslator.cpp:447
TermTranslator::getExponentString
const char * getExponentString(size_t variable, Exponent exponent) const
as getExponent, except the string "e" is returned, where e is the exponent.
Definition TermTranslator.cpp:410
Term
Term represents a product of variables which does not include a coefficient.
Definition Term.h:49
Term::getVarCount
size_t getVarCount() const
Definition Term.h:85
VarNames
Defines the variables of a polynomial ring and facilities IO involving them.
Definition VarNames.h:40
VarNames::addVar
bool addVar(const string &name)
Adds the variable and returns true if name is not already a variable.
Definition VarNames.cpp:44
VarNames::getVarCount
size_t getVarCount() const
Returns the current number of variables.
Definition VarNames.h:113
VarNames::getName
const string & getName(size_t index) const
The returned reference can become invalid next time addVar is called.
Definition VarNames.cpp:100
VarNames::clear
void clear()
Resets the number of variables to zero.
Definition VarNames.cpp:106
VarNames::addVarSyntaxCheckUnique
void addVarSyntaxCheckUnique(const Scanner &in, const string &name)
As addvar, except it reports a syntax error if name is already a variable.
Definition VarNames.cpp:68
displayNote
void displayNote(const string &msg)
Display msg to standard error in a way that indicates that this is something that the user should tak...
Definition display.cpp:135
display.h
This file contains functions for printing strings to standard error.
reportError
void reportError(const string &errorMsg)
Definition error.cpp:23
error.h
INTERNAL_ERROR_UNIMPLEMENTED
#define INTERNAL_ERROR_UNIMPLEMENTED()
Definition error.h:47
IO::Fourti2
Definition Fourti2IOHandler.cpp:38
IO::Fourti2::writeTerm
void writeTerm(const vector< mpz_class > &term, FILE *out)
Definition Fourti2IOHandler.cpp:340
IO::Fourti2::writeRing
void writeRing(const VarNames &names, FILE *out)
Definition Fourti2IOHandler.cpp:294
IO::Fourti2::writeRingWithoutHeader
void writeRingWithoutHeader(const VarNames &names, FILE *out)
Definition Fourti2IOHandler.cpp:299
IO::Fourti2::readRing
void readRing(Scanner &in, VarNames &names)
Definition Fourti2IOHandler.cpp:328
IO::Fourti2::readIdeal
void readIdeal(Scanner &in, InputConsumer &consumer, size_t generatorCount, size_t varCount)
The parsing of the header with the number of generators and variables has to be separate from the cod...
Definition Fourti2IOHandler.cpp:375
IO::Fourti2::readSatBinomIdeal
void readSatBinomIdeal(Scanner &in, SatBinomConsumer &consumer, size_t generatorCount, size_t varCount)
Definition Fourti2IOHandler.cpp:400
IO::Fourti2::display4ti2Warning
void display4ti2Warning()
Definition Fourti2IOHandler.cpp:427
IO::Fourti2::readTerm
void readTerm(Scanner &in, InputConsumer &consumer)
Definition Fourti2IOHandler.cpp:312
IO
Definition CoCoA4IOHandler.cpp:33
stdinc.h
This header file includes common definitions and is included as the first line of code in every imple...
ASSERT
#define ASSERT(X)
Definition stdinc.h:86