Java tutorial
/* * * * Project to resolve 2D cutting stock problem for Discreet Optimizations course at Polytech Lyon * * Copyright (C) 2015. CARON Antoine and CHAUSSENDE Adrien * * * * This program is free software: you can redistribute it and/or modify * * it under the terms of the GNU Affero General Public License as * * published by the Free Software Foundation, either version 3 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 Affero General Public License for more details. * * * * You should have received a copy of the GNU Affero General Public License * * along with this program. If not, see <http://www.gnu.org/licenses/>. * */ package com.polytech4A.cuttingstock.core.method; import org.apache.commons.math.util.FastMath; /** * Created by Adrien CHAUSSENDE on 27/03/2015. * * @author Adrien CHAUSSENDE * @version 1.0 * * Bin class to keep results from the methods for the 2D cutting stock problem. */ public class Result { /** * Number of printings for each pattern. */ private int[] printings; /** * Cost found during the resolution method. */ private int cost; public Result(double[] printings, int sheetCost, int patternCost) { int[] buf = new int[printings.length]; this.cost = 0; for (int i = 0; i < printings.length; ++i) { buf[i] = (int) FastMath.ceil(printings[i]); this.cost += buf[i] * sheetCost; } this.cost += patternCost * printings.length; this.printings = buf; } public Result(int[] printings, int cost) { this.printings = printings; this.cost = cost; } public double getCost() { return cost; } public int[] getPrintings() { return printings; } /** * Returns a string representation of the object. In general, the * {@code toString} method returns a string that * "textually represents" this object. The result should * be a concise but informative representation that is easy for a * person to read. * It is recommended that all subclasses override this method. * <p> * The {@code toString} method for class {@code Object} * returns a string consisting of the name of the class of which the * object is an instance, the at-sign character `{@code @}', and * the unsigned hexadecimal representation of the hash code of the * object. In other words, this method returns a string equal to the * value of: * <blockquote> * <pre> * getClass().getName() + '@' + Integer.toHexString(hashCode()) * </pre></blockquote> * * @return a string representation of the object. */ @Override public String toString() { StringBuffer stbf = new StringBuffer(); stbf.append("Cost :"); stbf.append(cost); stbf.append("\n"); stbf.append("Printings :["); for (int i = 0; i < printings.length; i++) { stbf.append(printings[i]); if (i != printings.length - 1) { stbf.append(","); } } stbf.append("]"); return stbf.toString(); } /** * Creates and returns a copy of this object. The precise meaning * of "copy" may depend on the class of the object. The general * intent is that, for any object {@code x}, the expression: * <blockquote> * <pre> * x.clone() != x</pre></blockquote> * will be true, and that the expression: * <blockquote> * <pre> * x.clone().getClass() == x.getClass()</pre></blockquote> * will be {@code true}, but these are not absolute requirements. * While it is typically the case that: * <blockquote> * <pre> * x.clone().equals(x)</pre></blockquote> * will be {@code true}, this is not an absolute requirement. * * By convention, the returned object should be obtained by calling * {@code super.clone}. If a class and all of its superclasses (except * {@code Object}) obey this convention, it will be the case that * {@code x.clone().getClass() == x.getClass()}. * * By convention, the object returned by this method should be independent * of this object (which is being cloned). To achieve this independence, * it may be necessary to modify one or more fields of the object returned * by {@code super.clone} before returning it. Typically, this means * copying any mutable objects that comprise the internal "deep structure" * of the object being cloned and replacing the references to these * objects with references to the copies. If a class contains only * primitive fields or references to immutable objects, then it is usually * the case that no fields in the object returned by {@code super.clone} * need to be modified. * * The method {@code clone} for class {@code Object} performs a * specific cloning operation. First, if the class of this object does * not implement the interface {@code Cloneable}, then a * {@code CloneNotSupportedException} is thrown. Note that all arrays * are considered to implement the interface {@code Cloneable} and that * the return type of the {@code clone} method of an array type {@code T[]} * is {@code T[]} where T is any reference or primitive type. * Otherwise, this method creates a new instance of the class of this * object and initializes all its fields with exactly the contents of * the corresponding fields of this object, as if by assignment; the * contents of the fields are not themselves cloned. Thus, this method * performs a "shallow copy" of this object, not a "deep copy" operation. * * The class {@code Object} does not itself implement the interface * {@code Cloneable}, so calling the {@code clone} method on an object * whose class is {@code Object} will result in throwing an * exception at run time. * * @return a clone of this instance. * @throws CloneNotSupportedException if the object's class does not * support the {@code Cloneable} interface. Subclasses * that override the {@code clone} method can also * throw this exception to indicate that an instance cannot * be cloned. * @see Cloneable */ @Override public Result clone() { return new Result(printings, cost); } }