static void rand() // 중복되지 않는 랜덤 숫자배열 두개 만들기
{
int su = 0; // 난수 발생시 저장할 변수
boolean bDash = false; // 중복여부 확인
for (int i = 0; i < 75; i++) {
bDash = true;
while (bDash) // 난수발생, 중복 학인
{
su = (int) (Math.random() * 75) + 1; // 판 크기+10개(상대가 못맞출 수도 있게)의 난수 입력
bDash = false;
for (int j = 0; j < i; j++) {
if (numArr1[j] == su) {
bDash = true; // 중복이 있으면 멈추고 while문을 다시 수행(랜덤값을 다시 줌)
break;
}
}
}
numArr1[i] = su;
}
for (int i = 0; i < 75; i++) {
bDash = true;
while (bDash) // 난수발생, 중복 학인
{
su = (int) (Math.random() * 75) + 1; // 판 크기+10개(상대가 못맞출 수도 있게)의 난수 입력
bDash = false;
for (int j = 0; j < i; j++) {
if (numArr2[j] == su) {
bDash = true; // 중복이 있으면 멈추고 while문을 다시 수행(랜덤값을 다시 줌)
break;
}
}
}
numArr2[i] = su;
}
}
private void adjustDateLineCrossingPoints() {
ArrayList<LatLon> corners = new ArrayList<LatLon>(Arrays.asList(sw, se, nw, ne));
if (!LatLon.locationsCrossDateLine(corners)) return;
double lonSign = 0;
for (LatLon corner : corners) {
if (Math.abs(corner.getLongitude().degrees) != 180)
lonSign = Math.signum(corner.getLongitude().degrees);
}
if (lonSign == 0) return;
if (Math.abs(sw.getLongitude().degrees) == 180
&& Math.signum(sw.getLongitude().degrees) != lonSign)
sw = new Position(sw.getLatitude(), sw.getLongitude().multiply(-1), sw.getElevation());
if (Math.abs(se.getLongitude().degrees) == 180
&& Math.signum(se.getLongitude().degrees) != lonSign)
se = new Position(se.getLatitude(), se.getLongitude().multiply(-1), se.getElevation());
if (Math.abs(nw.getLongitude().degrees) == 180
&& Math.signum(nw.getLongitude().degrees) != lonSign)
nw = new Position(nw.getLatitude(), nw.getLongitude().multiply(-1), nw.getElevation());
if (Math.abs(ne.getLongitude().degrees) == 180
&& Math.signum(ne.getLongitude().degrees) != lonSign)
ne = new Position(ne.getLatitude(), ne.getLongitude().multiply(-1), ne.getElevation());
}
/**
* Compute the bounds of the text, if necessary.
*
* @param dc the current DrawContext.
*/
protected void computeBoundsIfNeeded(DrawContext dc) {
// Do not compute bounds if they are available. Computing text bounds is expensive, so only do
// this
// calculation if necessary.
if (this.bounds != null) return;
TextRenderer textRenderer =
OGLTextRenderer.getOrCreateTextRenderer(dc.getTextRendererCache(), this.getFont());
int width = 0;
int maxLineHeight = 0;
this.lineBounds = new Rectangle2D[this.lines.length];
for (int i = 0; i < this.lines.length; i++) {
Rectangle2D lineBounds = textRenderer.getBounds(lines[i]);
width = (int) Math.max(lineBounds.getWidth(), width);
double thisLineHeight = Math.abs(lineBounds.getY());
maxLineHeight = (int) Math.max(thisLineHeight, maxLineHeight);
this.lineBounds[i] = lineBounds;
}
this.lineHeight = maxLineHeight;
// Compute final height using maxLineHeight and number of lines
this.bounds =
new Rectangle(
this.lines.length,
maxLineHeight,
width,
this.lines.length * maxLineHeight + this.lines.length * this.lineSpacing);
}
public void paint(Graphics g) {
level = level_in;
left_width_factor = (float) Math.pow(2.0, -1 / left_alpha);
right_width_factor = (float) Math.pow(2.0, -1 / right_alpha);
left_height_factor = (float) Math.pow(2.0, -2 / (3 * left_alpha));
right_height_factor = (float) Math.pow(2.0, -2 / (3 * right_alpha));
x = (float) 600 / 2.0f;
y = (float) 500 / 10.0f;
x1 = x;
y01 = y + height;
drawbranch(g, width, (int) x, 500 - (int) y, (int) x1, 500 - (int) y01);
turtle_r = height;
turtle_theta = point(x, y, x1, y01);
turtle_x = x;
turtle_y = y;
turn(left_angle);
generate(g, x1, y01, left_width_factor * width, left_height_factor * height, left_angle, level);
turtle_theta = point(x, y, x1, y01);
turn(-right_angle);
generate(g, x1, y01, width, left_height_factor * height, right_angle, level);
g.drawString("Fractal.java", 10, 10);
}
public void acceptMinimumSize(Component c) {
Dimension minimumSize = getMinimumSize(c);
c.setMinimumSize(
new Dimension(
Math.max(minimumSize.width, c.getMinimumSize().width),
Math.max(minimumSize.height, c.getMinimumSize().height)));
}
/** Frees memory by deleting a few slices from the end of the stack. */
public void trim() {
int n = (int) Math.round(Math.log(nSlices) + 1.0);
for (int i = 0; i < n; i++) {
deleteLastSlice();
System.gc();
}
}
@Override
public void showFeedback() {
createFeedback();
myBounds =
myContext.getTransformedRectangle(
myComponent.getBounds(myContext.getArea().getFeedbackLayer()));
myBounds.width = Math.max(myBounds.width, 0);
myBounds.height = Math.max(myBounds.height, 0);
int direction = myContext.getResizeDirection();
if ((direction & Position.EAST) != 0) {
if (!snapToWidth(myBounds, myWrapSize, SNAP_DELTA)) {
snapToWidth(myBounds, myFillSize, SNAP_DELTA);
}
}
if ((direction & Position.SOUTH) != 0) {
if (!snapToHeight(myBounds, myWrapSize, SNAP_DELTA)) {
snapToHeight(myBounds, myFillSize, SNAP_DELTA);
}
}
myFeedback.setBounds(myBounds);
myTextFeedback.clear();
addTextSize(myStaticWidth, myBounds.width, myWrapSize.width, myFillSize.width);
myTextFeedback.append(" x ", SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES);
addTextSize(myStaticHeight, myBounds.height, myWrapSize.height, myFillSize.height);
myTextFeedback.locationTo(myContext.getLocation(), 15);
}
// Give the string and horizontal and verical offsets so that the label is
// drawn in the center.
public void drawLabel(Graphics g, String label, int hoffset, int voffset) {
g.setColor(Color.black);
int pixelsPerNm = DrawPanel.PIXELS_PER_NM;
int xint = (int) Math.round(pixelsPerNm * z);
int yint = (int) Math.round(pixelsPerNm * y);
g.drawString(label, xint - hoffset, yint + voffset);
}
/**
* returns random 1 or -1
*
* @return random 1 or -1
*/
private int generateRandomSign() {
if (Math.round((Math.random() * 2)) == 1) {
return 1;
} else {
return -1;
}
}
private int wrapPositionForTabbedTextWithOptimization(
@NotNull CharSequence text,
int tabSize,
int startLineOffset,
int endLineOffset,
int targetRangeEndOffset) {
int width = 0;
int symbolWidth;
int result = Integer.MAX_VALUE;
boolean wrapLine = false;
for (int i = startLineOffset; i < Math.min(endLineOffset, targetRangeEndOffset); i++) {
char c = text.charAt(i);
switch (c) {
case '\t':
symbolWidth = tabSize - (width % tabSize);
break;
default:
symbolWidth = 1;
}
if (width + symbolWidth + FormatConstants.RESERVED_LINE_WRAP_WIDTH_IN_COLUMNS
>= mySettings.RIGHT_MARGIN
&& (Math.min(endLineOffset, targetRangeEndOffset) - i)
>= FormatConstants.RESERVED_LINE_WRAP_WIDTH_IN_COLUMNS) {
// Remember preferred position.
result = i - 1;
}
if (width + symbolWidth >= mySettings.RIGHT_MARGIN) {
wrapLine = true;
break;
}
width += symbolWidth;
}
return wrapLine ? result : -1;
}
@Override
public Dimension getPreferredSize() {
Dimension windowSize = DiffUtil.getDefaultDiffWindowSize();
Dimension size = super.getPreferredSize();
return new Dimension(
Math.max(windowSize.width, size.width), Math.max(windowSize.height, size.height));
}
/**
* Damages the area surrounding the caret to cause it to be repainted in a new location. If
* paint() is reimplemented, this method should also be reimplemented. This method should update
* the caret bounds (x, y, width, and height).
*
* @param r the current location of the caret
* @see #paint
*/
@Override
protected synchronized void damage(final Rectangle r) {
if (r == null || fPainting) return;
x = r.x - 4;
y = r.y;
width = 10;
height = r.height;
// Don't damage the border area. We can't paint a partial border, so get the
// intersection of the caret rectangle and the component less the border, if any.
final Rectangle caretRect = new Rectangle(x, y, width, height);
final Border border = getComponent().getBorder();
if (border != null) {
final Rectangle alloc = getComponent().getBounds();
alloc.x = alloc.y = 0;
final Insets borderInsets = border.getBorderInsets(getComponent());
alloc.x += borderInsets.left;
alloc.y += borderInsets.top;
alloc.width -= borderInsets.left + borderInsets.right;
alloc.height -= borderInsets.top + borderInsets.bottom;
Rectangle2D.intersect(caretRect, alloc, caretRect);
}
x = caretRect.x;
y = caretRect.y;
width = Math.max(caretRect.width, 1);
height = Math.max(caretRect.height, 1);
repaint();
}
public void update(double prob_slowdown, double prob_create) {
int i = 0;
while (i < LENGTH && speed[i] == -1) i++;
while (i < LENGTH) {
if (Math.random() <= prob_slowdown && speed[i] > 0) speed[i]--;
else if (speed[i] < MAXSPEED) speed[i]++;
int inext = i + 1;
while (inext < LENGTH && speed[inext] == -1) inext++;
if (inext < LENGTH) {
if (speed[i] >= inext - i) speed[i] = inext - i - 1;
}
if (speed[i] > 0) {
if (i + speed[i] < LENGTH) {
int ni = i + speed[i];
speed[ni] = speed[i];
colors[ni] = colors[i];
}
speed[i] = -1;
}
i = inext;
}
if (Math.random() <= prob_create && speed[0] == -1) {
speed[0] = (int) (5.99 * Math.random());
colors[0] = ++count % 10 == 0 ? Color.red : Color.black;
}
}
public Object down(Message msg) {
Address dest = msg.getDest();
boolean multicast = dest == null;
if (msg.getSrc() == null) msg.setSrc(localAddress());
if (discard_all) {
if (dest == null || dest.equals(localAddress())) loopback(msg);
return null;
}
if (!multicast && drop_down_unicasts > 0) {
drop_down_unicasts = Math.max(0, drop_down_unicasts - 1);
return null;
}
if (multicast && drop_down_multicasts > 0) {
drop_down_multicasts = Math.max(0, drop_down_multicasts - 1);
return null;
}
if (down > 0) {
double r = Math.random();
if (r < down) {
if (excludeItself && dest != null && dest.equals(localAddress())) {
if (log.isTraceEnabled()) log.trace("excluding itself");
} else {
log.trace("dropping message");
num_down++;
return null;
}
}
}
return down_prot.down(msg);
}
/**
* Calculates the maximum size dimensions for the specified panal given the components in the
* specified parent container.
*/
public Dimension maximumLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int size = actions.size();
if ((grip != null) && grip.isVisible()) {
Dimension d = grip.getPreferredSize();
dim.width += d.width;
dim.width += hgap;
}
Component last = null;
for (int i = 0; i < size; i++) {
Component comp = (Component) actions.elementAt(i);
if (comp.isVisible()) {
Dimension d = comp.getPreferredSize();
dim.width += d.width;
dim.height = Math.max(dim.height, d.height);
dim.width += hgap;
last = comp;
}
}
if (last != null) {
Dimension prefSize = last.getPreferredSize();
Dimension maxSize = last.getMaximumSize();
if (prefSize != maxSize) {
dim.width = dim.width - prefSize.width + maxSize.width;
dim.height = Math.max(dim.height, maxSize.height);
}
}
Insets insets = target.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
return dim;
}
}
/**
* Ensures that the caret is visible by scrolling the text area if necessary.
*
* @return True if scrolling was actually performed, false if the caret was already visible
*/
public boolean scrollToCaret() {
int line = getCaretLine();
int lineStart = getLineStartOffset(line);
int offset = Math.max(0, Math.min(getLineLength(line) - 1, getCaretPosition() - lineStart));
return scrollTo(line, offset);
}
/**
* Ensures that the specified line and offset is visible by scrolling the text area if necessary.
*
* @param line The line to scroll to
* @param offset The offset in the line to scroll to
* @return True if scrolling was actually performed, false if the line and offset was already
* visible
*/
public boolean scrollTo(int line, int offset) {
// visibleLines == 0 before the component is realized
// we can't do any proper scrolling then, so we have
// this hack...
if (visibleLines == 0) {
setFirstLine(Math.max(0, line - electricScroll));
return true;
}
int newFirstLine = firstLine;
int newHorizontalOffset = horizontalOffset;
if (line < firstLine + electricScroll) {
newFirstLine = Math.max(0, line - electricScroll);
} else if (line + electricScroll >= firstLine + visibleLines) {
newFirstLine = (line - visibleLines) + electricScroll + 1;
if (newFirstLine + visibleLines >= getLineCount())
newFirstLine = getLineCount() - visibleLines;
if (newFirstLine < 0) newFirstLine = 0;
}
int x = _offsetToX(line, offset);
int width = painter.getFontMetrics().charWidth('w');
if (x < 0) {
newHorizontalOffset = Math.min(0, horizontalOffset - x + width + 5);
} else if (x + width >= painter.getWidth()) {
newHorizontalOffset = horizontalOffset + (painter.getWidth() - x) - width - 5;
}
return setOrigin(newFirstLine, newHorizontalOffset);
}
public double distanciaEuclidiana(int x1, int x2, int y1, int y2) {
double a, b, c;
a = Math.pow(x2 - x1, 2);
b = Math.pow(y2 - y1, 2);
c = Math.sqrt(a + b);
return (c);
}
/**
* Write the given text string in the current font, centered on (x, y) and rotated by the
* specified number of degrees
*
* @param x the center x-coordinate of the text
* @param y the center y-coordinate of the text
* @param s the text
* @param degrees is the number of degrees to rotate counterclockwise
*/
public static void text(double x, double y, String s, double degrees) {
double xs = scaleX(x);
double ys = scaleY(y);
offscreen.rotate(Math.toRadians(-degrees), xs, ys);
text(x, y, s);
offscreen.rotate(Math.toRadians(+degrees), xs, ys);
}
private void setColumnPreferredSize() {
for (int i = 0; i < getColumnCount(); i++) {
TableColumn column = getColumnModel().getColumn(i);
if (i == AbstractVcsLogTableModel.ROOT_COLUMN) { // thin stripe or nothing
int rootWidth = myUI.getColorManager().isMultipleRoots() ? ROOT_INDICATOR_WIDTH : 0;
// NB: all further instructions and their order are important, otherwise the minimum size
// which is less than 15 won't be applied
column.setMinWidth(rootWidth);
column.setMaxWidth(rootWidth);
column.setPreferredWidth(rootWidth);
} else if (i
== AbstractVcsLogTableModel
.COMMIT_COLUMN) { // let commit message occupy as much as possible
column.setPreferredWidth(Short.MAX_VALUE);
} else if (i
== AbstractVcsLogTableModel.AUTHOR_COLUMN) { // detect author with the longest name
// to avoid querying the last row (it would lead to full graph loading)
int maxRowsToCheck =
Math.min(MAX_ROWS_TO_CALC_WIDTH, getRowCount() - MAX_ROWS_TO_CALC_OFFSET);
if (maxRowsToCheck < 0) { // but if the log is small, check all of them
maxRowsToCheck = getRowCount();
}
int contentWidth = calcMaxContentColumnWidth(i, maxRowsToCheck);
column.setMinWidth(Math.min(contentWidth, MAX_DEFAULT_AUTHOR_COLUMN_WIDTH));
column.setWidth(column.getMinWidth());
} else if (i == AbstractVcsLogTableModel.DATE_COLUMN) { // all dates have nearly equal sizes
Font tableFont = UIManager.getFont("Table.font");
column.setMinWidth(
getFontMetrics(tableFont)
.stringWidth("mm" + DateFormatUtil.formatDateTime(new Date())));
column.setWidth(column.getMinWidth());
}
}
}
/*
* Adjust the width of the scrollpane used by the popup
*/
protected void popupWider(BasicComboPopup popup) {
JList list = popup.getList();
// Determine the maximimum width to use:
// a) determine the popup preferred width
// b) limit width to the maximum if specified
// c) ensure width is not less than the scroll pane width
int popupWidth =
list.getPreferredSize().width
+ 5 // make sure horizontal scrollbar doesn't appear
+ getScrollBarWidth(popup, scrollPane);
if (maximumWidth != -1) {
popupWidth = Math.min(popupWidth, maximumWidth);
}
Dimension scrollPaneSize = scrollPane.getPreferredSize();
popupWidth = Math.max(popupWidth, scrollPaneSize.width);
// Adjust the width
scrollPaneSize.width = popupWidth;
scrollPane.setPreferredSize(scrollPaneSize);
scrollPane.setMaximumSize(scrollPaneSize);
}
public void paint(Graphics gg) {
int faceSize = Math.min(getWidth() - 4, getHeight() - 4);
if (face == null)
face =
new PADFaceMapped(
Math.max(2, (getWidth() - faceSize) / 2),
Math.max(2, (getHeight() - faceSize) / 2),
faceSize);
if (buffer == null) {
im = this.createImage(getWidth(), getHeight());
buffer = im.getGraphics();
}
super.paint(buffer);
buffer.setColor(new Color(255, 255, 255, 0));
buffer.fillRect(0, 0, im.getWidth(null), im.getHeight(null));
face.setDimensions(
Math.max(2, (getWidth() - faceSize) / 2),
Math.max(2, (getHeight() - faceSize) / 2),
faceSize);
face.paint(buffer);
// draw buffer to screen
gg.drawImage(im, 0, 0, null, null);
}
void createEllipse(ImagePlus imp) {
IJ.showStatus("Fitting ellipse");
Roi roi = imp.getRoi();
if (roi == null) {
noRoi("Fit Ellipse");
return;
}
if (roi.isLine()) {
IJ.error("Fit Ellipse", "\"Fit Ellipse\" does not work with line selections");
return;
}
ImageProcessor ip = imp.getProcessor();
ip.setRoi(roi);
int options = Measurements.CENTROID + Measurements.ELLIPSE;
ImageStatistics stats = ImageStatistics.getStatistics(ip, options, null);
double dx = stats.major * Math.cos(stats.angle / 180.0 * Math.PI) / 2.0;
double dy = -stats.major * Math.sin(stats.angle / 180.0 * Math.PI) / 2.0;
double x1 = stats.xCentroid - dx;
double x2 = stats.xCentroid + dx;
double y1 = stats.yCentroid - dy;
double y2 = stats.yCentroid + dy;
double aspectRatio = stats.minor / stats.major;
imp.killRoi();
imp.setRoi(new EllipseRoi(x1, y1, x2, y2, aspectRatio));
}
public void enemyPosition(ScannedRobotEvent e, double x, double y) {
// poll subtargetters for their opinions
virtualBulletTick++;
lastEnemyScanTime = owner.getTime();
// only log it when we actually fire: the enemy may respond to that
if (owner.shouldFireShot(e)) {
double bulletPower = e.getDistance() > 500.0 ? 2.0 : 3.0;
for (int i = 0; i < numVirtualGuns; i++) {
double angle = targetters[i].target(e, bulletPower);
VirtualBullet bullet = new VirtualBullet();
bullet.targetter = i;
bullet.x = owner.getX();
bullet.y = owner.getY();
bullet.velX = Targetting.bulletSpeed(bulletPower) * Math.sin(angle);
bullet.velY = Targetting.bulletSpeed(bulletPower) * Math.cos(angle);
bullet.lastUpdateTime = lastEnemyScanTime;
virtualBullets.add(bullet);
}
}
for (int i = 0; i < numVirtualGuns; i++) {
targetters[i].enemyPosition(e, x, y);
}
enemyX = x;
enemyY = y;
}
/**
* Draw the LineSelection at its current location. It is the responsibility of the
* applet/application to draw the LineSelection at the appropriate times, e.g., inside the
* component's update() and/or paint() method. This gives maximum flexibility for double
* buffering, etc.
*
* @param g The Graphics context to use for drawing.
*/
public void draw(Graphics g) {
if (!isVisible()) {
return;
}
Color saveColor = g.getColor();
g.setColor(color);
if (thickness > 1) {
double ratio = ((double) thickness) / ((double) length());
double txdb = ratio * ((double) height) / 2.0;
int tx = txdb > 0 ? ((int) Math.ceil(txdb)) : ((int) Math.floor(txdb));
double tydb = -ratio * ((double) width) / 2.0;
int ty = tydb > 0 ? ((int) Math.ceil(tydb)) : ((int) Math.floor(tydb));
Point[] poly = new Point[4];
for (int i = 0; i < 4; i++) poly[i] = new Point(x, y);
poly[0].translate(tx, ty);
poly[1].translate(-tx, -ty);
poly[2].translate(width, height);
poly[2].translate(-tx, -ty);
poly[3].translate(width, height);
poly[3].translate(tx, ty);
Polygon polygon = new Polygon();
for (int i = 0; i < 4; i++) polygon.addPoint(poly[i].x, poly[i].y);
g.fillPolygon(polygon);
} else g.drawLine(x, y, x + width, y + height);
g.setColor(saveColor);
} // end draw
/**
* Returns a list of pairs of x coordinates for visual ranges representing given logical range. If
* <code>startOffset == endOffset</code>, a pair of equal numbers is returned, corresponding to
* target position. Target offsets are supposed to be located on the same visual line.
*/
private TFloatArrayList logicalRangeToVisualRanges(int startOffset, int endOffset) {
assert startOffset <= endOffset;
TFloatArrayList result = new TFloatArrayList();
for (VisualLineFragmentsIterator.Fragment fragment :
VisualLineFragmentsIterator.create(myView, startOffset, false)) {
int minOffset = fragment.getMinOffset();
int maxOffset = fragment.getMaxOffset();
if (startOffset == endOffset) {
if (startOffset >= minOffset && startOffset <= maxOffset) {
float x = fragment.offsetToX(startOffset);
result.add(x);
result.add(x);
break;
}
} else if (startOffset < maxOffset && endOffset > minOffset) {
float x1 = fragment.offsetToX(Math.max(minOffset, startOffset));
float x2 = fragment.offsetToX(Math.min(maxOffset, endOffset));
if (x1 > x2) {
float tmp = x1;
x1 = x2;
x2 = tmp;
}
if (result.isEmpty() || x1 > result.get(result.size() - 1)) {
result.add(x1);
result.add(x2);
} else {
result.set(result.size() - 1, x2);
}
}
}
return result;
}
public void printLoop(int n, float x[], float y[]) {
// Need to swap the y component
Polygon P = new Polygon();
for (int i = 0; i < n; i++) P.addPoint(Math.round(x[i]), Math.round(height - y[i]));
poly_draw.add(P);
poly_draw_color.add(curColor);
}
@NotNull
private Dimension expandIfNecessary(@NotNull Dimension base) {
if (base.width >= myMinWidth && base.height >= myMinHeight) {
return base;
}
return new Dimension(Math.max(myMinWidth, base.width), Math.max(myMinHeight, base.height));
}
public void EMpar(Database db, double prior) {
int j, np;
double x, y, tmp, tmpx, tmpy, tmpsx, tmpsy, tmpsxy;
np = db.nPoints();
tmpsx = tmpsy = tmpsxy = kmx = kmy = 0;
for (j = 0; j < np; j++) {
x = db.xVal(j);
y = db.yVal(j);
kmx += probs[j] * x;
kmy += probs[j] * y;
tmpsx += probs[j] * x * x;
tmpsy += probs[j] * y * y;
tmpsxy += probs[j] * x * y;
}
tmp = np * weight;
kmx /= tmp;
kmy /= tmp;
ksx = Math.sqrt(tmpsx / tmp - kmx * kmx);
ksy = Math.sqrt(tmpsy / tmp - kmy * kmy);
ksxy = tmpsxy / tmp - kmx * kmy;
if (ksx < mins) ksx = mins;
if (ksy < mins) ksy = mins;
weight = 0.9 * weight + 0.1 * prior;
}
// Proceso para posicionar las imagenes en el concentrece
public void cargarImagenes() {
int x, y = 0;
int numero = -1;
double x1, y1 = 0;
ficha = new int[a][b];
// Incializacion de la matriz entera en -1
for (int i = 0; i < getA(); i++) {
for (int j = 0; j < getB(); j++) {
ficha[i][j] = -1;
}
}
// Proceso de introduccion de imagenes en posiciones aleatorias para
// obtener mas variaciones del juego
for (int i = 0; i < getA(); i++) {
for (int j = 0; j < getB(); j++) {
do {
x1 = Math.random() * getA();
y1 = Math.random() * getB();
x = (int) x1;
y = (int) y1;
} while (ficha[x][y] != -1);
numero++;
if (numero == getC()) {
numero = 0;
}
ficha[x][y] = numero;
parejas[i][j].setIcon(vacio);
}
}
}