/** * Returns a dense array representing the potential pool permanences * * <p>Note: Only called from tests for now... * * @param c * @return */ public double[] getDensePermanences(Connections c) { double[] retVal = new double[c.getNumInputs()]; int[] keys = synapsesBySourceIndex.keys(); for (int inputIndex : keys) { retVal[inputIndex] = synapsesBySourceIndex.get(inputIndex).getPermanence(); } return retVal; }
/** * Returns an array of permanence values * * @return */ public double[] getSparsePermanences() { double[] retVal = new double[size]; int[] keys = synapsesBySourceIndex.keys(); for (int x = 0, j = size - 1; x < size; x++, j--) { retVal[j] = synapsesBySourceIndex.get(keys[x]).getPermanence(); } return retVal; }
public void setUp() { if (!map.isEmpty()) return; for (int j = 0; j < 2; j++) { for (Integer i : BenchmarkRunner.INTEGERS) { map.put(i.intValue(), i); } } }
public void testSplitClassesIdxs() throws Exception { final TIntObjectMap<TIntList> classesIdxs = MCTools.splitClassesIdxs(target); final TIntArrayList expectedForClass15 = new TIntArrayList(new int[] {0, 1, 2, 3, 4}); assertTrue(Arrays.equals(expectedForClass15.toArray(), classesIdxs.get(15).toArray())); final TIntArrayList expectedForClass3 = new TIntArrayList(new int[] {9, 10, 11}); assertTrue(Arrays.equals(expectedForClass3.toArray(), classesIdxs.get(3).toArray())); }
public int[] mergeValues(final int x, final int z, final int sizeX, final int sizeZ) { final int gridX = x - 1; final int gridZ = z - 1; final int gridSizeX = sizeX + 2; final int gridSizeZ = sizeZ + 2; final int[] values = this.belowLayer.generateValues(gridX, gridZ, gridSizeX, gridSizeZ); final int[] eValues = this.variationLayer.generateValues(gridX, gridZ, gridSizeX, gridSizeZ); final int[] finalValues = new int[sizeX * sizeZ]; for (int i = 0; i < sizeZ; i++) { for (int j = 0; j < sizeX; j++) { this.setCoordsSeed(x + j, z + i); final int centerValue = values[(j + 1 + ((i + 1) * gridSizeX))]; final int variationValue = eValues[(j + 1 + ((i + 1) * gridSizeX))]; if ((centerValue != 0) && (variationValue == 3) && (centerValue < VARIATION_MOD)) { finalValues[(j + (i * sizeX))] = (getByBiomeId(centerValue + VARIATION_MOD) != null) ? (centerValue + VARIATION_MOD) : centerValue; } else if ((variationValue == 2) || (this.nextInt(3) == 0)) { int val = centerValue; if (VARIATIONS.containsKey(centerValue)) { val = VARIATIONS.get(centerValue).get(this.nextInt(VARIATIONS.get(centerValue).size())); } else if ((centerValue == DEEP_OCEAN.getBiomeId()) && (this.nextInt(3) == 0)) { val = ISLANDS.get(this.nextInt(ISLANDS.size())); } if ((variationValue == 2) && (val != centerValue)) { val = (getByBiomeId(val + VARIATION_MOD) != null) ? (val + VARIATION_MOD) : centerValue; } if (val != centerValue) { int count = 0; if (values[(j + 1 + (i * gridSizeX))] == centerValue) { // upper value count++; } if (values[(j + 1 + ((i + 2) * gridSizeX))] == centerValue) { // lower value count++; } if (values[(j + ((i + 1) * gridSizeX))] == centerValue) { // left value count++; } if (values[(j + 2 + ((i + 1) * gridSizeX))] == centerValue) { // right value count++; } // spread mountains if not too close from an edge finalValues[(j + (i * sizeX))] = (count < 3) ? centerValue : val; } else { finalValues[(j + (i * sizeX))] = val; } } else { finalValues[(j + (i * sizeX))] = centerValue; } } } return finalValues; }
/** * Actual setter. * * @param id Database ID * @param index column index * @param value new value * @param <T> type * @return previous value */ @SuppressWarnings("unchecked") protected <T> T set(DBIDRef id, int index, T value) { Object[] d = data.get(DBIDUtil.asInteger(id)); if (d == null) { d = new Object[rlen]; data.put(DBIDUtil.asInteger(id), d); } T ret = (T) d[index]; d[index] = value; return ret; }
/** * Updates this {@code Pool}'s store of permanences for the specified {@link Synapse} * * @param c the connections memory * @param s the synapse who's permanence is recorded * @param permanence the permanence value to record */ public void updatePool(Connections c, Synapse s, double permanence) { int inputIndex = s.getInputIndex(); if (synapsesBySourceIndex.get(inputIndex) == null) { synapsesBySourceIndex.put(inputIndex, s); } if (permanence > c.getSynPermConnected()) { synapseConnections.add(inputIndex); } else { synapseConnections.remove(inputIndex); } }
@Override public Path calcPath(int from, int to) { if (alreadyRun) throw new IllegalStateException("Create a new instance per call"); alreadyRun = true; TIntObjectMap<AStarEdge> map = new TIntObjectHashMap<AStarEdge>(); PriorityQueue<AStarEdge> prioQueueOpenSet = new PriorityQueue<AStarEdge>(1000); double toLat = graph.getLatitude(to); double toLon = graph.getLongitude(to); double currWeightToGoal, distEstimation, tmpLat, tmpLon; AStarEdge fromEntry = new AStarEdge(EdgeIterator.NO_EDGE, from, 0, 0); AStarEdge currEdge = fromEntry; while (true) { int currVertex = currEdge.endNode; EdgeIterator iter = neighbors(currVertex); while (iter.next()) { if (!accept(iter)) continue; int neighborNode = iter.adjNode(); double alreadyVisitedWeight = weightCalc.getWeight(iter.distance(), iter.flags()) + currEdge.weightToCompare; AStarEdge nEdge = map.get(neighborNode); if (nEdge == null || nEdge.weightToCompare > alreadyVisitedWeight) { tmpLat = graph.getLatitude(neighborNode); tmpLon = graph.getLongitude(neighborNode); currWeightToGoal = dist.calcDist(toLat, toLon, tmpLat, tmpLon); currWeightToGoal = weightCalc.getMinWeight(currWeightToGoal); distEstimation = alreadyVisitedWeight + currWeightToGoal; if (nEdge == null) { nEdge = new AStarEdge(iter.edge(), neighborNode, distEstimation, alreadyVisitedWeight); map.put(neighborNode, nEdge); } else { prioQueueOpenSet.remove(nEdge); nEdge.edge = iter.edge(); nEdge.weight = distEstimation; nEdge.weightToCompare = alreadyVisitedWeight; } nEdge.parent = currEdge; prioQueueOpenSet.add(nEdge); updateShortest(nEdge, neighborNode); } } visitedCount++; if (finished(currEdge, to)) break; if (prioQueueOpenSet.isEmpty()) return new Path(graph, flagEncoder); currEdge = prioQueueOpenSet.poll(); if (currEdge == null) throw new AssertionError("cannot happen?"); } return extractPath(currEdge); }
public static void main(String[] args) { if (args.length != 2) { System.err.println( "Usage: MemoryBasedLeft2Right <in score file> <out aggregated scores redis file>"); System.exit(0); } String infile = args[0]; String redisSimilarityFile = args[1]; try { BufferedReader reader = new BufferedReader(new FileReader(new File(infile))); String line; TIntObjectMap<TIntDoubleMap> scoresMap = new TIntObjectHashMap<TIntDoubleMap>(); while ((line = reader.readLine()) != null) { String[] toks = line.split("\t"); int id1 = Integer.parseInt(toks[0]); int id2 = Integer.parseInt(toks[1]); double score = Double.parseDouble(toks[2]); TIntDoubleMap scores = scoresMap.get(id1); if (scores == null) { scores = new TIntDoubleHashMap(); scoresMap.put(id1, scores); } scores.put(id2, score); } reader.close(); RedisBasedIDKeyPersistentBasicMap<LinkedHashMap<Integer, Double>> redis = new RedisBasedIDKeyPersistentBasicMap<LinkedHashMap<Integer, Double>>( redisSimilarityFile, false); redis.clear(); TIntObjectIterator<TIntDoubleMap> it = scoresMap.iterator(); while (it.hasNext()) { it.advance(); int id1 = it.key(); TIntDoubleMap scores = it.value(); redis.put(id1, SortUtil.sortMapByValue(scores, true)); } } catch (Exception e) { e.printStackTrace(); } }
/** * Actual getter. * * @param id Database ID * @param index column index * @param <T> type * @return current value */ @SuppressWarnings("unchecked") protected <T> T get(DBIDRef id, int index) { Object[] d = data.get(DBIDUtil.asInteger(id)); if (d == null) { return null; } return (T) d[index]; }
/** * Replaces the contents of this vertex data by the provided one. This is a deep copy. The vertex * attribute are each individually cloned. * * @param data The data to copy. */ public void copy(VertexData data) { clear(); indices.addAll(data.indices); final TIntObjectIterator<VertexAttribute> iterator = data.attributes.iterator(); while (iterator.hasNext()) { iterator.advance(); attributes.put(iterator.key(), iterator.value().clone()); } nameToIndex.putAll(data.nameToIndex); }
public void run() { int total = 0; for (int i = 0; i < 5; i++) { TIntObjectIterator<Integer> iterator = map.iterator(); while (iterator.hasNext()) { iterator.advance(); total += iterator.key(); } } }
public FrequencyRandomOffsets(RaptorWorkerData data) { this.data = data; if (!data.hasFrequencies) return; data.timetablesForPattern .stream() .filter(tt -> tt.hasFrequencyTrips()) .forEach( tt -> { offsets.put(tt.dataIndex, new int[tt.getFrequencyTripCount()]); }); }
public void randomize() { for (TIntObjectIterator<int[]> it = offsets.iterator(); it.hasNext(); ) { it.advance(); int[] newVal = new int[it.value().length]; RaptorWorkerTimetable tt = data.timetablesForPattern.get(it.key()); for (int i = 0; i < newVal.length; i++) { newVal[i] = mt.nextInt(tt.headwaySecs[i]); } it.setValue(newVal); } }
/** * Uses 2 streetSearches to get P+R path * * <p>First CAR search from fromLat/fromLon to all car parks. Then from those found places WALK * search. * * <p>Result is then used as access part. Since P+R in direct mode is useless. * * @param request profileRequest from which from/to destination is used * @param streetRouter where profileRequest was already set * @return null if path isn't found */ private StreetRouter findParkRidePath(ProfileRequest request, StreetRouter streetRouter) { streetRouter.streetMode = StreetMode.CAR; streetRouter.timeLimitSeconds = request.maxCarTime * 60; streetRouter.flagSearch = VertexStore.VertexFlag.PARK_AND_RIDE; streetRouter.dominanceVariable = StreetRouter.State.RoutingVariable.DURATION_SECONDS; if (streetRouter.setOrigin(request.fromLat, request.fromLon)) { streetRouter.route(); TIntObjectMap<StreetRouter.State> carParks = streetRouter.getReachedVertices(VertexStore.VertexFlag.PARK_AND_RIDE); LOG.info("CAR PARK: Found {} car parks", carParks.size()); StreetRouter walking = new StreetRouter(transportNetwork.streetLayer); walking.streetMode = StreetMode.WALK; walking.profileRequest = request; walking.timeLimitSeconds = request.maxCarTime * 60; walking.transitStopSearch = true; walking.setOrigin(carParks, CAR_PARK_DROPOFF_TIME_S, CAR_PARK_DROPOFF_COST, LegMode.CAR_PARK); walking.dominanceVariable = StreetRouter.State.RoutingVariable.DURATION_SECONDS; walking.route(); walking.previousRouter = streetRouter; return walking; } else { return null; } }
@Test public void testTroveMapPreservesSynapseOrdering() { Synapse s = new Synapse(); TIntObjectMap<Synapse> t = new TIntObjectHashMap<>(); t.put(2, s); t.put(4, s); t.put(6, s); t.put(8, s); t.put(10, s); t.put(12, s); int[] expectedKeys = {12, 10, 8, 6, 4, 2}; assertTrue(Arrays.equals(expectedKeys, t.keys())); // Insert a cell index in the middle, check that order is still // preserved following inserts t.put(3, s); expectedKeys = new int[] {12, 10, 8, 6, 4, 3, 2}; assertTrue(Arrays.equals(expectedKeys, t.keys())); // Check reversing produces ascending ordered Synapses expectedKeys = new int[] {2, 3, 4, 6, 8, 10, 12}; assertTrue(Arrays.equals(expectedKeys, ArrayUtils.reverse(t.keys()))); }
public JumpTrack getTrack(int id) { return _jumpingTracks.get(id); }
public void addTrack(JumpTrack track) { _jumpingTracks.put(track.getId(), track); }
/** * Inserts a city. * * @param city The city to insert. * @return This CityManager. */ public CityManager insertCity(City city) { cities.put(city.getId(), city); registerLandOwner(city); return this; }
/** * Gets a list of all cities on the server. * * @return */ public List<City> getCityList() { return new ArrayList<City>(cities.valueCollection()); }
/** * Gets a city from its integer id. * * @param id * @return */ public City getCity(int id) { return cities.get(id); }
/** * Adds an attribute. * * @param attribute The attribute to add */ public void addAttribute(int index, VertexAttribute attribute) { attributes.put(index, attribute); nameToIndex.put(attribute.getName(), index); }
/** Clears all the vertex data. */ public void clear() { indices.clear(); attributes.clear(); nameToIndex.clear(); }
/** * Returns the attribute count. * * @return The number of attributes */ public int getAttributeCount() { return attributes.size(); }
/** * Removes the attribute at the provided index. If no attribute is found, nothing will be removed. * * @param index The index of the attribute to remove */ public void removeAttribute(int index) { attributes.remove(index); nameToIndex.remove(getAttributeName(index)); }
/** * Returns true in an attribute can be found at the provided index. * * @param index The index to lookup * @return Whether or not an attribute is at the index */ public boolean hasAttribute(int index) { return attributes.containsKey(index); }
public BgOpLogPartition get(int tableId) { return tableOplogMap.get(tableId); }
@Override public int size() { return _jumpingTracks.size(); }
@Override public void clear() { _jumpingTracks.clear(); }
/** * Returns the {@link VertexAttribute} at the desired index, or null if none is associated to the * index. * * @param index The index to lookup * @return The attribute, or null if none is associated to the index. */ public VertexAttribute getAttribute(int index) { return attributes.get(index); }