/**
* Gets the types array.
*
* @return the types array
*/
public ArrayList<String> getTypeArray() {
ArrayList<String> result = new ArrayList<String>();
for (Attribute attr : this) {
result.add(attr.getType());
}
return result;
}
/**
* Generates output file for a clasification problem @ param Foutput Name of the output file @
* param real Vector of outputs instances @ param obtained Vector of net outputs
*
* @return Nothing
*/
public void generateResultsClasification(String Foutput, int[] real, int[] obtained) {
// Output file, classification problems
FileOutputStream out;
PrintStream p;
Attribute at = Attributes.getOutputAttribute(0);
// Check whether the output value is nominal or integer
boolean isNominal = (at.getType() == at.NOMINAL);
try {
out = new FileOutputStream(Foutput);
p = new PrintStream(out);
CopyHeaderTest(p);
// System.out.println("Longitudes "+real.length+" "+obtained.length);
for (int i = 0; i < real.length; i++) {
// Write the label associated to the class number,
// when the output is nominal
if (isNominal)
p.print(at.getNominalValue(real[i]) + " " + at.getNominalValue(obtained[i]) + "\n");
else p.print(real[i] + " " + obtained[i] + "\n");
}
p.close();
} catch (Exception e) {
System.err.println("Error building file for results: " + Foutput);
}
}
/**
*
*
* <pre>
* Usage: Discretizer
* -r attribute file path
* -i input dataset path
* -o output dataset path
* [-d] discretized attribute file path
* [-m] output attribute file path
* [-n] maximum num of bins (default: 256)
* [-t] training file path
* </pre>
*
* @param args the command line arguments.
* @throws Exception
*/
public static void main(String[] args) throws Exception {
Options app = new Options();
CmdLineParser parser = new CmdLineParser(Discretizer.class, app);
try {
parser.parse(args);
if (app.maxNumBins < 0) {
throw new IllegalArgumentException();
}
} catch (IllegalArgumentException e) {
parser.printUsage();
System.exit(1);
}
List<Attribute> attributes = null;
if (app.trainPath != null) {
Instances trainSet = InstancesReader.read(app.attPath, app.trainPath);
attributes = trainSet.getAttributes();
for (int i = 0; i < attributes.size(); i++) {
Attribute attribute = attributes.get(i);
if (attribute.getType() == Type.NUMERIC) {
// Only discretize numeric attributes
Discretizer.discretize(trainSet, i, app.maxNumBins);
}
}
} else if (app.disAttPath != null) {
attributes = AttributesReader.read(app.disAttPath).v1;
} else {
parser.printUsage();
System.exit(1);
}
Instances instances = InstancesReader.read(app.attPath, app.inputPath);
List<Attribute> attrs = instances.getAttributes();
for (int i = 0; i < attrs.size(); i++) {
Attribute attr = attrs.get(i);
if (attr.getType() == Type.NUMERIC) {
BinnedAttribute binnedAttr = (BinnedAttribute) attributes.get(i);
// Only discretize numeric attributes
Discretizer.discretize(instances, i, binnedAttr.getBins());
}
}
if (app.outputAttPath != null) {
InstancesWriter.write(instances, app.outputAttPath, app.outputPath);
} else {
InstancesWriter.write(instances, app.outputPath);
}
}
/**
* Compute the number of all possible conditions that could appear in a rule of a given data. For
* nominal attributes, it's the number of values that could appear; for numeric attributes, it's
* the number of values * 2, i.e. <= and >= are counted as different possible conditions.
*
* @return number of all conditions of the data
*/
public double numAllConditions() {
double total = 0;
for (int i = 0; i < Attributes.getInputNumAttributes(); i++) {
Attribute att = Attributes.getInputAttribute(i);
if (att.getType() == Attribute.NOMINAL) total += (double) att.getNumNominalValues();
else total += 2.0 * (double) numDistinctValues(i);
}
return total;
}
@Test
public void testAttributeInfersTypeFromSetter() throws Exception {
// given
final Method setter = getSetter(new PrivateTarget());
// when
final Attribute<String> attribute = newSetterAttribute(setter);
// then
assertEquals(Methods.getSetterType(setter), attribute.getType());
}
private static Attribute createAttribute(Map<String, String> beanAttr)
throws InternalErrorException {
if (beanAttr == null) return null;
Attribute attribute = new Attribute();
attribute.setId(Integer.valueOf(beanAttr.get("id")).intValue());
attribute.setFriendlyName(BeansUtils.eraseEscaping(beanAttr.get("friendlyName")));
attribute.setNamespace(BeansUtils.eraseEscaping(beanAttr.get("namespace")));
attribute.setType(BeansUtils.eraseEscaping(beanAttr.get("type")));
attribute.setValue(
BeansUtils.stringToAttributeValue(
BeansUtils.eraseEscaping(beanAttr.get("value")), attribute.getType()));
return attribute;
}
private void deserializeRule(DeserializationContext context, Build.Rule rulePb)
throws PackageDeserializationException, InterruptedException {
Location ruleLocation = EmptyLocation.INSTANCE;
RuleClass ruleClass = packageDeserializationEnvironment.getRuleClass(rulePb, ruleLocation);
Map<String, ParsedAttributeValue> attributeValues = new HashMap<>();
AttributesToDeserialize attrToDeserialize =
packageDeserializationEnvironment.attributesToDeserialize();
Hasher hasher = Hashing.md5().newHasher();
for (Build.Attribute attrPb : rulePb.getAttributeList()) {
Type<?> type = ruleClass.getAttributeByName(attrPb.getName()).getType();
attributeValues.put(attrPb.getName(), deserializeAttribute(type, attrPb));
if (attrToDeserialize.addSyntheticAttributeHash) {
// TODO(bazel-team): This might give false positives because of explicit vs implicit.
hasher.putBytes(attrPb.toByteArray());
}
}
AttributeContainerWithoutLocation attributeContainer =
new AttributeContainerWithoutLocation(ruleClass, hasher.hash());
Label ruleLabel = deserializeLabel(rulePb.getName());
try {
Rule rule =
createRuleWithParsedAttributeValues(
ruleClass,
ruleLabel,
context.packageBuilder,
ruleLocation,
attributeValues,
NullEventHandler.INSTANCE,
attributeContainer);
context.packageBuilder.addRule(rule);
// Remove the attribute after it is added to package in order to pass the validations
// and be able to compute all the outputs.
if (attrToDeserialize != DESERIALIZE_ALL_ATTRS) {
for (String attrName : attributeValues.keySet()) {
Attribute attribute = ruleClass.getAttributeByName(attrName);
if (!(attrToDeserialize.shouldKeepAttributeWithName.apply(attrName)
|| BuildType.isLabelType(attribute.getType()))) {
attributeContainer.clearIfNotLabel(attrName);
}
}
}
Preconditions.checkState(!rule.containsErrors());
} catch (NameConflictException | LabelSyntaxException e) {
throw new PackageDeserializationException(e);
}
}
public void addAttribute(Attribute attribute) {
attribute.setSchema(this);
// comprobación de clones de tablas
GeopistaSchema schema = this;
// busca si existe otra tabla con este nombre
// java2xml desvincula las tablas y crea múltiples instancias
for (int i = 0; i < schema.getAttributeCount(); i++) {
if (schema
.getColumnByAttribute(i)
.getTable()
.getName()
.equals(attribute.getColumn().getTable().getName())) {
// Es un clon de la ya existente -> uso la existente en lugar del parámetro.
attribute.getColumn().setTable(schema.getColumnByAttribute(i).getTable());
}
}
/**
* Busca si existe un dominio con el mismo nombre de tipo TreeDomain java2xml desvincula los
* dominios y crea instancias separadas
*/
Domain newdomain = attribute.getColumn().getDomain();
if (newdomain instanceof TreeDomain) {
TreeDomain newTreeDomain = (TreeDomain) newdomain;
// busca por nombre de dominio
for (int i = 0; i < schema.getAttributeCount(); i++) {
if (schema.getAttributeDomain(i) != null
&& schema.getAttributeDomain(i).getName().equals(newTreeDomain.getName())) {
// se ha encontrado el dominio ya definido: Usamos el actual
Domain dom = schema.getAttributeDomain(i);
newTreeDomain = (TreeDomain) dom; // overrides suplied domain
}
}
attribute.getColumn().setDomain(newTreeDomain);
// enlaza la columna actual al dominio existente
int level = newTreeDomain.getLevelNames().indexOf(attribute.getColumn().getName());
if (level > -1) newTreeDomain.attachColumnToLevel(attribute.getColumn(), level);
}
addAttribute(
attribute.getName(),
AttributeType.toAttributeType(attribute.getType()),
attribute.getColumn(),
attribute.getAccessType());
}
/**
* Computes the distance between two instances (without previous normalization)
*
* @param i First instance
* @param j Second instance
* @return The Euclidean distance between i and j
*/
private double distance(Instance i, Instance j) {
double dist = 0;
int in = 0;
int out = 0;
for (int l = 0; l < nvariables; l++) {
Attribute a = Attributes.getAttribute(l);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !i.getInputMissingValues(in)) {
// real value, apply euclidean distance
dist +=
(i.getInputRealValues(in) - j.getInputRealValues(in))
* (i.getInputRealValues(in) - j.getInputRealValues(in));
} else {
if (!i.getInputMissingValues(in)
&& i.getInputNominalValues(in) != j.getInputNominalValues(in)) dist += 1;
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !i.getOutputMissingValues(out)) {
dist +=
(i.getOutputRealValues(out) - j.getOutputRealValues(out))
* (i.getOutputRealValues(out) - j.getOutputRealValues(out));
} else {
if (!i.getOutputMissingValues(out)
&& i.getOutputNominalValues(out) != j.getOutputNominalValues(out)) dist += 1;
}
out++;
}
}
}
return dist;
}
/**
* Compute the number of all possible conditions that could appear in a rule of a given data. For
* nominal attributes, it's the number of values that could appear; for numeric attributes, it's
* the number of values * 2, i.e. <= and >= are counted as different possible conditions.
*
* @param attIndex the attribute' index
* @return number of all conditions of the data
*/
public double numAllConditions(int attIndex) {
Attribute att = Attributes.getInputAttribute(attIndex);
if (att.getType() == Attribute.NOMINAL) return (double) att.getNumNominalValues();
else return 2.0 * (double) numDistinctValues(attIndex);
}
/** Function to stores header of a data file. */
private void readHeader() {
String attributeName;
Vector attributeValues;
int i;
name = Attributes.getRelationName();
// Create vectors to hold information temporarily.
attributes = new Vector();
Attribute at;
// store attribute inputs and of the header
for (int j = 0; j < Attributes.getInputNumAttributes(); j++) {
at = Attributes.getInputAttribute(j);
attributeName = at.getName();
// check if it is real
if (at.getType() == 2) {
float min = (float) at.getMinAttribute();
float max = (float) at.getMinAttribute();
attributes.addElement(new MyAttribute(attributeName, j));
MyAttribute att = (MyAttribute) attributes.elementAt(j);
att.setRange(min, max);
att.activate();
} else {
if (at.getType() == 1) // check if it is integer
{
int min = (int) at.getMinAttribute();
int max = (int) at.getMinAttribute();
attributes.addElement(new MyAttribute(attributeName, j));
MyAttribute att = (MyAttribute) attributes.elementAt(j);
att.setRange(min, max);
att.activate();
} else // it is nominal
{
attributeValues = new Vector();
for (int k = 0; k < at.getNumNominalValues(); k++) {
attributeValues.addElement(at.getNominalValue(k));
}
attributes.addElement(new MyAttribute(attributeName, attributeValues, j));
MyAttribute att = (MyAttribute) attributes.elementAt(j);
att.activate();
}
}
} // for
// store outputs of the header
at = Attributes.getOutputAttribute(0);
attributeName = at.getName();
int j = Attributes.getNumAttributes() - 1;
// check if it is real
if (at.getType() == 2) {
float min = (float) at.getMinAttribute();
float max = (float) at.getMinAttribute();
attributes.addElement(new MyAttribute(attributeName, j));
MyAttribute att = (MyAttribute) attributes.elementAt(j);
att.setRange(min, max);
att.activate();
} else {
if (at.getType() == 1) // check if it is integer
{
int min = (int) at.getMinAttribute();
int max = (int) at.getMinAttribute();
attributes.addElement(new MyAttribute(attributeName, j));
MyAttribute att = (MyAttribute) attributes.elementAt(j);
att.setRange(min, max);
att.activate();
} else // it is nominal
{
attributeValues = new Vector();
for (int k = 0; k < at.getNumNominalValues(); k++) {
attributeValues.addElement(at.getNominalValue(k));
}
attributes.addElement(new MyAttribute(attributeName, attributeValues, j));
MyAttribute att = (MyAttribute) attributes.elementAt(j);
att.activate();
}
}
// set the index of the output class
classIndex = Attributes.getNumAttributes() - 1;
}
/**
* Writes results
*
* @param nombreFichero Name of the output file
* @param salidaKNN Instances to write
* @param prediccion Instances to mantain
* @param entradas Input attributes characteristics
* @param salida Output attribute characteristics
* @param nEntradas Number of input attributes
* @param relation Name of the data set
*/
public static void escribeSalida(
String nombreFichero,
int[][] salidaKNN,
int[][] prediccion,
Attribute entradas[],
Attribute salida,
int nEntradas,
String relation) {
int n_ejemplos, n_salidas = 0;
String cadena = "";
int i, j;
/*Printing input attributes*/
cadena += "@relation " + relation + "\n";
for (i = 0; i < nEntradas; i++) {
cadena += "@attribute " + entradas[i].getName() + " ";
if (entradas[i].getType() == Attribute.NOMINAL) {
cadena += "{";
for (j = 0; j < entradas[i].getNominalValuesList().size(); j++) {
cadena += (String) entradas[i].getNominalValuesList().elementAt(j);
if (j < entradas[i].getNominalValuesList().size() - 1) {
cadena += ", ";
}
}
cadena += "}\n";
} else {
if (entradas[i].getType() == Attribute.INTEGER) {
cadena += "integer";
} else {
cadena += "real";
}
cadena +=
" ["
+ String.valueOf(entradas[i].getMinAttribute())
+ ", "
+ String.valueOf(entradas[i].getMaxAttribute())
+ "]\n";
}
}
/*Printing output attribute*/
cadena += "@attribute " + salida.getName() + " ";
if (salida.getType() == Attribute.NOMINAL) {
cadena += "{";
for (j = 0; j < salida.getNominalValuesList().size(); j++) {
cadena += (String) salida.getNominalValuesList().elementAt(j);
if (j < salida.getNominalValuesList().size() - 1) {
cadena += ", ";
}
}
cadena += "}\n";
} else {
cadena +=
"integer ["
+ String.valueOf(salida.getMinAttribute())
+ ", "
+ String.valueOf(salida.getMaxAttribute())
+ "]\n";
}
/*Printing the data*/
cadena += "@data\n";
Fichero.escribeFichero(nombreFichero, cadena);
n_ejemplos = salidaKNN.length;
if (n_ejemplos > 0) n_salidas = salidaKNN[0].length;
for (i = 0; i < n_ejemplos; i++) {
cadena = "";
for (j = 0; j < n_salidas; j++) cadena += "" + salidaKNN[i][j] + " ";
for (j = 0; j < n_salidas; j++) cadena += "" + prediccion[i][j] + " ";
cadena += "\n";
Fichero.AnadirtoFichero(nombreFichero, cadena);
}
} // end-method
public static void main(String[] args) {
try {
// Read arguments
if (args.length != 3) {
System.out.println("Usage: PFX <dbdir> <infile> <outfile>");
System.exit(-1);
}
// open input file for reading
FileInputStream infile = null;
try {
infile = new FileInputStream(args[1]);
} catch (FileNotFoundException f) {
System.out.println("Cannot open file " + args[1] + " for reading: " + f.getMessage());
return;
}
int certfile = 0;
// initialize CryptoManager. This is necessary because there is
// crypto involved with decoding a PKCS #12 file
CryptoManager.initialize(args[0]);
CryptoManager manager = CryptoManager.getInstance();
// Decode the P12 file
PFX.Template pfxt = new PFX.Template();
PFX pfx = (PFX) pfxt.decode(new BufferedInputStream(infile, 2048));
System.out.println("Decoded PFX");
// print out information about the top-level PFX structure
System.out.println("Version: " + pfx.getVersion());
AuthenticatedSafes authSafes = pfx.getAuthSafes();
SEQUENCE safeContentsSequence = authSafes.getSequence();
System.out.println("AuthSafes has " + safeContentsSequence.size() + " SafeContents");
// Get the password for the old file
System.out.println("Enter password: "******"Enter new password:"******"AuthSafes verifies correctly.");
} else {
System.out.println("AuthSafes failed to verify because: " + sb);
}
// Create a new AuthenticatedSafes. As we read the contents of the
// old authSafes, we will store them into the new one. After we have
// cycled through all the contents, they will all have been copied into
// the new authSafes.
AuthenticatedSafes newAuthSafes = new AuthenticatedSafes();
// Loop over contents of the old authenticated safes
// for(int i=0; i < asSeq.size(); i++) {
for (int i = 0; i < safeContentsSequence.size(); i++) {
// The safeContents may or may not be encrypted. We always send
// the password in. It will get used if it is needed. If the
// decryption of the safeContents fails for some reason (like
// a bad password), then this method will throw an exception
SEQUENCE safeContents = authSafes.getSafeContentsAt(pass, i);
System.out.println("\n\nSafeContents #" + i + " has " + safeContents.size() + " bags");
// Go through all the bags in this SafeContents
for (int j = 0; j < safeContents.size(); j++) {
SafeBag safeBag = (SafeBag) safeContents.elementAt(j);
// The type of the bag is an OID
System.out.println("\nBag " + j + " has type " + safeBag.getBagType());
// look for bag attributes
SET attribs = safeBag.getBagAttributes();
if (attribs == null) {
System.out.println("Bag has no attributes");
} else {
for (int b = 0; b < attribs.size(); b++) {
Attribute a = (Attribute) attribs.elementAt(b);
if (a.getType().equals(SafeBag.FRIENDLY_NAME)) {
// the friendly name attribute is a nickname
BMPString bs =
(BMPString)
((ANY) a.getValues().elementAt(0)).decodeWith(BMPString.getTemplate());
System.out.println("Friendly Name: " + bs);
} else if (a.getType().equals(SafeBag.LOCAL_KEY_ID)) {
// the local key id is used to match a key
// to its cert. The key id is the SHA-1 hash of
// the DER-encoded cert.
OCTET_STRING os =
(OCTET_STRING)
((ANY) a.getValues().elementAt(0)).decodeWith(OCTET_STRING.getTemplate());
System.out.println("LocalKeyID:");
/*
AuthenticatedSafes.
print_byte_array(os.toByteArray());
*/
} else {
System.out.println("Unknown attribute type: " + a.getType().toString());
}
}
}
// now look at the contents of the bag
ASN1Value val = safeBag.getInterpretedBagContent();
if (val instanceof PrivateKeyInfo) {
// A PrivateKeyInfo contains an unencrypted private key
System.out.println("content is PrivateKeyInfo");
} else if (val instanceof EncryptedPrivateKeyInfo) {
// An EncryptedPrivateKeyInfo is, well, an encrypted
// PrivateKeyInfo. Usually, strong crypto is used in
// an EncryptedPrivateKeyInfo.
EncryptedPrivateKeyInfo epki = ((EncryptedPrivateKeyInfo) val);
System.out.println(
"content is EncryptedPrivateKeyInfo, algoid:"
+ epki.getEncryptionAlgorithm().getOID());
// Because we are in a PKCS #12 file, the passwords are
// char-to-byte converted in a special way. We have to
// use the special converter class instead of the default.
PrivateKeyInfo pki = epki.decrypt(pass, new org.mozilla.jss.pkcs12.PasswordConverter());
// import the key into the key3.db
CryptoToken tok = manager.getTokenByName("Internal Key Storage Token");
CryptoStore store = tok.getCryptoStore();
tok.login(new ConsolePasswordCallback());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
pki.encode(baos);
store.importPrivateKey(baos.toByteArray(), PrivateKey.RSA);
// re-encrypt the PrivateKeyInfo with the new password
// and random salt
byte[] salt = new byte[PBEAlgorithm.PBE_SHA1_DES3_CBC.getSaltLength()];
JSSSecureRandom rand = CryptoManager.getInstance().getSecureRNG();
rand.nextBytes(salt);
epki =
EncryptedPrivateKeyInfo.createPBE(
PBEAlgorithm.PBE_SHA1_DES3_CBC, newPass, salt, 1, new PasswordConverter(), pki);
// Overwrite the previous EncryptedPrivateKeyInfo with
// this new one we just created using the new password.
// This is what will get put in the new PKCS #12 file
// we are creating.
safeContents.insertElementAt(
new SafeBag(safeBag.getBagType(), epki, safeBag.getBagAttributes()), i);
safeContents.removeElementAt(i + 1);
} else if (val instanceof CertBag) {
System.out.println("content is CertBag");
CertBag cb = (CertBag) val;
if (cb.getCertType().equals(CertBag.X509_CERT_TYPE)) {
// this is an X.509 certificate
OCTET_STRING os = (OCTET_STRING) cb.getInterpretedCert();
Certificate cert =
(Certificate) ASN1Util.decode(Certificate.getTemplate(), os.toByteArray());
cert.getInfo().print(System.out);
} else {
System.out.println("Unrecognized cert type");
}
} else {
System.out.println("content is ANY");
}
}
// Add the new safe contents to the new authsafes
if (authSafes.safeContentsIsEncrypted(i)) {
newAuthSafes.addEncryptedSafeContents(
authSafes.DEFAULT_KEY_GEN_ALG,
newPass,
null,
authSafes.DEFAULT_ITERATIONS,
safeContents);
} else {
newAuthSafes.addSafeContents(safeContents);
}
}
// Create new PFX from the new authsafes
PFX newPfx = new PFX(newAuthSafes);
// Add a MAC to the new PFX
newPfx.computeMacData(newPass, null, PFX.DEFAULT_ITERATIONS);
// write the new PFX out to a file
FileOutputStream fos = new FileOutputStream(args[2]);
newPfx.encode(fos);
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/** Process the training and test files provided in the parameters file to the constructor. */
public void process() {
// declarations
double[] outputs;
double[] outputs2;
Instance neighbor;
double dist, mean;
int actual;
Randomize rnd = new Randomize();
Instance ex;
gCenter kmeans = null;
int iterations = 0;
double E;
double prevE;
int totalMissing = 0;
boolean allMissing = true;
rnd.setSeed(semilla);
// PROCESS
try {
// Load in memory a dataset that contains a classification problem
IS.readSet(input_train_name, true);
int in = 0;
int out = 0;
ndatos = IS.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
X = new String[ndatos][nvariables]; // matrix with transformed data
kmeans = new gCenter(K, ndatos, nvariables);
timesSeen = new FreqList[nvariables];
mostCommon = new String[nvariables];
// first, we choose k 'means' randomly from all
// instances
totalMissing = 0;
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
if (inst.existsAnyMissingValue()) totalMissing++;
}
if (totalMissing == ndatos) allMissing = true;
else allMissing = false;
for (int numMeans = 0; numMeans < K; numMeans++) {
do {
actual = (int) (ndatos * rnd.Rand());
ex = IS.getInstance(actual);
} while (ex.existsAnyMissingValue() && !allMissing);
kmeans.copyCenter(ex, numMeans);
}
// now, iterate adjusting clusters' centers and
// instances to them
prevE = 0;
iterations = 0;
do {
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
kmeans.setClusterOf(inst, i);
}
// set new centers
kmeans.recalculateCenters(IS);
// compute RMSE
E = 0;
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
E += kmeans.distance(inst, kmeans.getClusterOf(i));
}
iterations++;
// System.out.println(iterations+"\t"+E);
if (Math.abs(prevE - E) == 0) iterations = maxIter;
else prevE = E;
} while (E > minError && iterations < maxIter);
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
in = 0;
out = 0;
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in)) {
X[i][j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.getInputMissingValues(in)) X[i][j] = inst.getInputNominalValues(in);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
X[i][j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out)) X[i][j] = inst.getOutputNominalValues(out);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
out++;
}
}
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
write_results(output_train_name);
/** ************************************************************************************ */
// does a test file associated exist?
if (input_train_name.compareTo(input_test_name) != 0) {
try {
// Load in memory a dataset that contains a classification problem
IStest.readSet(input_test_name, false);
int in = 0;
int out = 0;
ndatos = IStest.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
for (int i = 0; i < ndatos; i++) {
Instance inst = IStest.getInstance(i);
in = 0;
out = 0;
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in)) {
X[i][j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.getInputMissingValues(in)) X[i][j] = inst.getInputNominalValues(in);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
X[i][j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out)) X[i][j] = inst.getOutputNominalValues(out);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
out++;
}
}
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
write_results(output_test_name);
}
}
/** Process the training and test files provided in the parameters file to the constructor. */
public void process() {
double[] outputs;
double[] outputs2;
try {
FileWriter file_write = new FileWriter(output_train_name);
try {
// Load in memory a dataset that contains a classification problem
IS.readSet(input_train_name, true);
int in = 0;
int out = 0;
int in2 = 0;
int out2 = 0;
int lastMissing = -1;
boolean fin = false;
boolean stepNext = false;
ndatos = IS.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
String[] row = null;
X = new Vector[ndatos]; // matrix with transformed data
for (int i = 0; i < ndatos; i++) X[i] = new Vector();
timesSeen = new FreqList[nvariables];
mostCommon = new String[nvariables];
file_write.write(IS.getHeader());
// now, print the normalized data
file_write.write("@data\n");
// now, search for missed data, and replace them with
// the most common value
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
in = 0;
out = 0;
row = new String[nvariables];
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.existsAnyMissingValue()) {
row[j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.existsAnyMissingValue()) row[j] = inst.getInputNominalValues(in);
else {
// missing data
outputs = inst.getAllOutputValues();
in2 = 0;
out2 = 0;
for (int attr = 0; attr < nvariables; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in2)) {
row[attr] = new String(String.valueOf(inst.getInputRealValues(in2)));
} else {
if (!inst.getInputMissingValues(in2))
row[attr] = inst.getInputNominalValues(in2);
}
in2++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out2)) {
row[attr] = new String(String.valueOf(inst.getOutputRealValues(out2)));
} else {
if (!inst.getOutputMissingValues(out2))
row[attr] = inst.getOutputNominalValues(out2);
}
out2++;
}
}
}
// make frecuencies for each attribute
for (int attr = 0; attr < nvariables; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT && inst.getInputMissingValues(attr)) {
lastMissing = attr;
timesSeen[attr] = new FreqList();
for (int m = 0; m < ndatos; m++) {
Instance inst2 = IS.getInstance(m);
outputs2 = inst2.getAllOutputValues();
boolean sameClass = true;
// are they same concept instances??
for (int k = 0; k < nsalidas && sameClass; k++)
if (outputs[k] != outputs2[k]) sameClass = false;
if (sameClass) {
if (tipo != Attribute.NOMINAL && !inst2.getInputMissingValues(attr)) {
timesSeen[attr].AddElement(
new String(String.valueOf(inst2.getInputRealValues(attr))));
} else {
if (!inst2.getInputMissingValues(attr)) {
timesSeen[attr].AddElement(inst2.getInputNominalValues(attr));
}
}
}
}
}
}
for (int attr = 0; attr < nvariables; attr++) {
if (direccion == Attribute.INPUT && inst.getInputMissingValues(attr)) {
timesSeen[attr].reset();
}
}
fin = false;
stepNext = false;
while (!fin) {
in2 = 0;
for (int attr = 0; attr < nvariables && !fin; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT && inst.getInputMissingValues(in2)) {
if (stepNext) {
timesSeen[attr].iterate();
stepNext = false;
}
if (timesSeen[attr].outOfBounds()) {
stepNext = true;
if (attr == lastMissing) fin = true;
timesSeen[attr].reset();
}
if (!fin)
row[attr] =
((ValueFreq) timesSeen[attr].getCurrent())
.getValue(); // replace missing data
}
in2++;
}
if (!fin) {
stepNext = true;
file_write.write(row[0]);
for (int y = 1; y < nvariables; y++) {
file_write.write("," + row[y]);
}
file_write.write("\n");
// X[i].addElement(row);
// row = (String[])row.clone();
}
}
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
row[j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out)) row[j] = inst.getOutputNominalValues(out);
else row[j] = new String("?");
}
out++;
}
}
}
if (!inst.existsAnyMissingValue()) {
file_write.write(row[0]);
for (int y = 1; y < nvariables; y++) {
file_write.write("," + row[y]);
}
file_write.write("\n");
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
file_write.close();
} catch (IOException e) {
System.out.println("IO exception = " + e);
e.printStackTrace();
System.exit(-1);
}
/** ************************************************************************************ */
// does a test file associated exist?
if (input_train_name.compareTo(input_test_name) != 0) {
try {
FileWriter file_write = new FileWriter(output_test_name);
try {
// Load in memory a dataset that contains a classification problem
IS.readSet(input_test_name, false);
int in = 0;
int out = 0;
int in2 = 0;
int out2 = 0;
int lastMissing = -1;
boolean fin = false;
boolean stepNext = false;
ndatos = IS.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
String[] row = null;
X = new Vector[ndatos]; // matrix with transformed data
for (int i = 0; i < ndatos; i++) X[i] = new Vector();
timesSeen = new FreqList[nvariables];
mostCommon = new String[nvariables];
file_write.write(IS.getHeader());
// now, print the normalized data
file_write.write("@data\n");
// now, search for missed data, and replace them with
// the most common value
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
in = 0;
out = 0;
row = new String[nvariables];
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.existsAnyMissingValue()) {
row[j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.existsAnyMissingValue()) row[j] = inst.getInputNominalValues(in);
else {
// missing data
outputs = inst.getAllOutputValues();
in2 = 0;
out2 = 0;
for (int attr = 0; attr < nvariables; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in2)) {
row[attr] = new String(String.valueOf(inst.getInputRealValues(in2)));
} else {
if (!inst.getInputMissingValues(in2))
row[attr] = inst.getInputNominalValues(in2);
}
in2++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out2)) {
row[attr] = new String(String.valueOf(inst.getOutputRealValues(out2)));
} else {
if (!inst.getOutputMissingValues(out2))
row[attr] = inst.getOutputNominalValues(out2);
}
out2++;
}
}
}
// make frecuencies for each attribute
for (int attr = 0; attr < nvariables; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT && inst.getInputMissingValues(attr)) {
lastMissing = attr;
timesSeen[attr] = new FreqList();
for (int m = 0; m < ndatos; m++) {
Instance inst2 = IS.getInstance(m);
outputs2 = inst2.getAllOutputValues();
boolean sameClass = true;
// are they same concept instances??
for (int k = 0; k < nsalidas && sameClass; k++)
if (outputs[k] != outputs2[k]) sameClass = false;
if (sameClass) {
if (tipo != Attribute.NOMINAL && !inst2.getInputMissingValues(attr)) {
timesSeen[attr].AddElement(
new String(String.valueOf(inst2.getInputRealValues(attr))));
} else {
if (!inst2.getInputMissingValues(attr)) {
timesSeen[attr].AddElement(inst2.getInputNominalValues(attr));
}
}
}
}
}
}
for (int attr = 0; attr < nvariables; attr++) {
if (direccion == Attribute.INPUT && inst.getInputMissingValues(attr)) {
timesSeen[attr].reset();
}
}
fin = false;
stepNext = false;
while (!fin) {
in2 = 0;
for (int attr = 0; attr < nvariables && !fin; attr++) {
Attribute b = Attributes.getAttribute(attr);
direccion = b.getDirectionAttribute();
tipo = b.getType();
if (direccion == Attribute.INPUT && inst.getInputMissingValues(in2)) {
if (stepNext) {
timesSeen[attr].iterate();
stepNext = false;
}
if (timesSeen[attr].outOfBounds()) {
stepNext = true;
if (attr == lastMissing) fin = true;
timesSeen[attr].reset();
}
if (!fin)
row[attr] =
((ValueFreq) timesSeen[attr].getCurrent())
.getValue(); // replace missing data
}
in2++;
}
if (!fin) {
stepNext = true;
file_write.write(row[0]);
for (int y = 1; y < nvariables; y++) {
file_write.write("," + row[y]);
}
file_write.write("\n");
// X[i].addElement(row);
// row = (String[])row.clone();
}
}
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
row[j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out))
row[j] = inst.getOutputNominalValues(out);
else row[j] = new String("?");
}
out++;
}
}
}
if (!inst.existsAnyMissingValue()) {
file_write.write(row[0]);
for (int y = 1; y < nvariables; y++) {
file_write.write("," + row[y]);
}
file_write.write("\n");
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
file_write.close();
} catch (IOException e) {
System.out.println("IO exception = " + e);
e.printStackTrace();
System.exit(-1);
}
}
}
protected static void escribeSalida(
String nombreFichero,
String instanciasIN[],
String instanciasOUT[],
Attribute entradas[],
Attribute salida,
int nEntradas,
String relation) {
String cadena = "";
int i, j, k;
int aux;
/* Printing input attributes */
cadena += "@relation " + relation + "\n";
for (i = 0; i < nEntradas; i++) {
cadena += "@attribute " + entradas[i].getName() + " ";
if (entradas[i].getType() == Attribute.NOMINAL) {
cadena += "{";
for (j = 0; j < entradas[i].getNominalValuesList().size(); j++) {
cadena += (String) entradas[i].getNominalValuesList().elementAt(j);
if (j < entradas[i].getNominalValuesList().size() - 1) {
cadena += ", ";
}
}
cadena += "}\n";
} else {
if (entradas[i].getType() == Attribute.INTEGER) {
cadena += "integer";
cadena +=
" ["
+ String.valueOf((int) entradas[i].getMinAttribute())
+ ", "
+ String.valueOf((int) entradas[i].getMaxAttribute())
+ "]\n";
} else {
cadena += "real";
cadena +=
" ["
+ String.valueOf(entradas[i].getMinAttribute())
+ ", "
+ String.valueOf(entradas[i].getMaxAttribute())
+ "]\n";
}
}
}
/* Printing output attribute */
cadena += "@attribute " + salida.getName() + " ";
if (salida.getType() == Attribute.NOMINAL) {
cadena += "{";
for (j = 0; j < salida.getNominalValuesList().size(); j++) {
cadena += (String) salida.getNominalValuesList().elementAt(j);
if (j < salida.getNominalValuesList().size() - 1) {
cadena += ", ";
}
}
cadena += "}\n";
} else {
cadena +=
"integer ["
+ String.valueOf((int) salida.getMinAttribute())
+ ", "
+ String.valueOf((int) salida.getMaxAttribute())
+ "]\n";
}
/* Printing the data */
cadena += "@data\n";
Fichero.escribeFichero(nombreFichero, cadena);
cadena = "";
for (i = 0; i < instanciasIN.length; i++) {
cadena += instanciasIN[i] + " " + instanciasOUT[i];
cadena += "\n";
}
Fichero.AnadirtoFichero(nombreFichero, cadena);
}
public void ejecutar() {
int i, j, l, m;
double alfai;
int nClases;
int claseObt;
boolean marcas[];
boolean notFound;
int init;
int clasSel[];
int baraje[];
int pos, tmp;
String instanciasIN[];
String instanciasOUT[];
long tiempo = System.currentTimeMillis();
/* Getting the number of differents classes */
nClases = 0;
for (i = 0; i < clasesTrain.length; i++) if (clasesTrain[i] > nClases) nClases = clasesTrain[i];
nClases++;
/* Shuffle the train set */
baraje = new int[datosTrain.length];
Randomize.setSeed(semilla);
for (i = 0; i < datosTrain.length; i++) baraje[i] = i;
for (i = 0; i < datosTrain.length; i++) {
pos = Randomize.Randint(i, datosTrain.length - 1);
tmp = baraje[i];
baraje[i] = baraje[pos];
baraje[pos] = tmp;
}
/*
* Inicialization of the flagged instaces vector for a posterior
* elimination
*/
marcas = new boolean[datosTrain.length];
for (i = 0; i < datosTrain.length; i++) marcas[i] = false;
if (datosTrain.length > 0) {
// marcas[baraje[0]] = true; //the first instance is included always
nSel = n_p;
if (nSel < nClases) nSel = nClases;
} else {
System.err.println("Input dataset is empty");
nSel = 0;
}
clasSel = new int[nClases];
System.out.print("Selecting initial neurons... ");
// at least, there must be 1 neuron of each class at the beginning
init = nClases;
for (i = 0; i < nClases && i < datosTrain.length; i++) {
pos = Randomize.Randint(0, datosTrain.length - 1);
tmp = 0;
while ((clasesTrain[pos] != i || marcas[pos]) && tmp < datosTrain.length) {
pos = (pos + 1) % datosTrain.length;
tmp++;
}
if (tmp < datosTrain.length) marcas[pos] = true;
else init--;
// clasSel[i] = i;
}
for (i = init; i < Math.min(nSel, datosTrain.length); i++) {
tmp = 0;
pos = Randomize.Randint(0, datosTrain.length - 1);
while (marcas[pos]) {
pos = (pos + 1) % datosTrain.length;
tmp++;
}
// if(i<nClases){
// notFound = true;
// do{
// for(j=i-1;j>=0 && notFound;j--){
// if(clasSel[j] == clasesTrain[pos])
// notFound = false;
// }
// if(!notFound)
// pos = Randomize.Randint (0, datosTrain.length-1);
// }while(!notFound);
// }
// clasSel[i] = clasesTrain[pos];
marcas[pos] = true;
init++;
}
nSel = init;
System.out.println("Initial neurons selected: " + nSel);
/* Building of the S set from the flags */
conjS = new double[nSel][datosTrain[0].length];
clasesS = new int[nSel];
for (m = 0, l = 0; m < datosTrain.length; m++) {
if (marcas[m]) { // the instance must be copied to the solution
for (j = 0; j < datosTrain[0].length; j++) {
conjS[l][j] = datosTrain[m][j];
}
clasesS[l] = clasesTrain[m];
l++;
}
}
alfai = alpha;
boolean change = true;
/* Body of the LVQ algorithm. */
// Train the network
for (int it = 0; it < T && change; it++) {
change = false;
alpha = alfai;
for (i = 1; i < datosTrain.length; i++) {
// search for the nearest neuron to training instance
pos = NN(nSel, conjS, datosTrain[baraje[i]]);
// nearest neuron labels correctly the class of training
// instance?
if (clasesS[pos] != clasesTrain[baraje[i]]) { // NO - repel
// the neuron
for (j = 0; j < conjS[pos].length; j++) {
conjS[pos][j] = conjS[pos][j] - alpha * (datosTrain[baraje[i]][j] - conjS[pos][j]);
}
change = true;
} else { // YES - migrate the neuron towards the input vector
for (j = 0; j < conjS[pos].length; j++) {
conjS[pos][j] = conjS[pos][j] + alpha * (datosTrain[baraje[i]][j] - conjS[pos][j]);
}
}
alpha = nu * alpha;
}
// Shuffle again the training partition
baraje = new int[datosTrain.length];
for (i = 0; i < datosTrain.length; i++) baraje[i] = i;
for (i = 0; i < datosTrain.length; i++) {
pos = Randomize.Randint(i, datosTrain.length - 1);
tmp = baraje[i];
baraje[i] = baraje[pos];
baraje[pos] = tmp;
}
}
System.out.println(
"LVQ " + relation + " " + (double) (System.currentTimeMillis() - tiempo) / 1000.0 + "s");
// Classify the train data set
instanciasIN = new String[datosReferencia.length];
instanciasOUT = new String[datosReferencia.length];
for (i = 0; i < datosReferencia.length; i++) {
/* Classify the instance selected in this iteration */
Attribute a = Attributes.getOutputAttribute(0);
int tipo = a.getType();
claseObt = KNN.evaluacionKNN2(1, conjS, clasesS, datosReferencia[i], nClases);
if (tipo != Attribute.NOMINAL) {
instanciasIN[i] = new String(String.valueOf(clasesReferencia[i]));
instanciasOUT[i] = new String(String.valueOf(claseObt));
} else {
instanciasIN[i] = new String(a.getNominalValue(clasesReferencia[i]));
instanciasOUT[i] = new String(a.getNominalValue(claseObt));
}
}
escribeSalida(
ficheroSalida[0], instanciasIN, instanciasOUT, entradas, salida, nEntradas, relation);
// Classify the test data set
normalizarTest();
instanciasIN = new String[datosTest.length];
instanciasOUT = new String[datosTest.length];
for (i = 0; i < datosTest.length; i++) {
/* Classify the instance selected in this iteration */
Attribute a = Attributes.getOutputAttribute(0);
int tipo = a.getType();
claseObt = KNN.evaluacionKNN2(1, conjS, clasesS, datosTest[i], nClases);
if (tipo != Attribute.NOMINAL) {
instanciasIN[i] = new String(String.valueOf(clasesTest[i]));
instanciasOUT[i] = new String(String.valueOf(claseObt));
} else {
instanciasIN[i] = new String(a.getNominalValue(clasesTest[i]));
instanciasOUT[i] = new String(a.getNominalValue(claseObt));
}
}
escribeSalida(
ficheroSalida[1], instanciasIN, instanciasOUT, entradas, salida, nEntradas, relation);
// Print the network to a file
printNetworkToFile(ficheroSalida[2], referencia.getHeader());
}
public static String getCreateTableStatement(Table table) {
if (table == null) {
return null;
}
if (TextUtils.isEmpty(table.getName())) {
return null;
}
if (table.getAttributeCount() < 1) {
return null;
}
String s = "CREATE TABLE IF NOT EXISTS [" + table.getName() + "] ( ";
ArrayList<String> primeAttributeList = new ArrayList<String>();
for (int i = 0; i < table.getAttributeCount(); i++) {
if (i != 0) {
s += ", ";
}
Attribute attribute = table.getAttribute(i);
s += "[" + attribute.getName() + "] ";
s += "[" + attribute.getType() + "] ";
if (Attribute.ATTRIBUTE_TYPE_TEXT.equals(attribute.getType())
|| Attribute.ATTRIBUTE_TYPE_BLOB.equals(attribute.getType())) {
if (attribute.getLength() > 0) {
s += "(" + attribute.getLength() + ") ";
}
} else if (Attribute.ATTRIBUTE_TYPE_REAL.equals(attribute.getType())) {
if (attribute.getLength() > 0) {
if (attribute.getDecimalLength() > 0) {
s += "(" + attribute.getLength() + "," + attribute.getDecimalLength() + ") ";
} else {
s += "(" + attribute.getLength() + ") ";
}
}
}
if (attribute.getName().equals(table.getAutoIncrementColumn())) {
if (Attribute.ATTRIBUTE_TYPE_INTEGER.equals(attribute.getType())) {
s += "PRIMARY KEY AUTOINCREMENT ";
} else {
return null;
}
}
if (!attribute.isAllowNull()) {
s += "NOT NULL ";
}
if (!TextUtils.isEmpty(attribute.getDefaultValue())) {
s += "DEFAULT [" + attribute.getDefaultValue() + "] ";
}
if (attribute.isPrimeAttribute()) {
primeAttributeList.add(attribute.getName());
}
}
if (TextUtils.isEmpty(table.getAutoIncrementColumn()) && primeAttributeList.size() > 0) {
s += ", PRIMARY KEY ( ";
for (int i = 0; i < primeAttributeList.size(); i++) {
if (i != 0) {
s += ", ";
}
s += "[" + primeAttributeList.get(i) + "] ";
}
s += ") ";
}
s += ");";
return s;
}
