/**
* Calculate the instrument sensitivity from the yield sensitivity, the jacobian matrix and the
* coupon sensitivity.
*
* @param curveSensitivities The sensitivity to points of the yield curve.
* @param curves The curve bundle.
* @param couponSensitivity The sensitivity
* @param jacobian The present value coupon sensitivity.
* @return The instrument quote/rate sensitivity.
*/
public DoubleMatrix1D calculateFromPresentValue(
final Map<String, List<DoublesPair>> curveSensitivities,
final YieldCurveBundle curves,
final DoubleMatrix1D couponSensitivity,
final DoubleMatrix2D jacobian) {
final DoubleArrayList resultList = new DoubleArrayList();
for (final String curveName : curves.getAllNames()) {
final DoubleMatrix1D nodeSensitivity =
new DoubleMatrix1D(
(_parameterSensitivityCalculator.pointToParameterSensitivity(
curveSensitivities.get(curveName), curves.getCurve(curveName)))
.toArray(new Double[0]));
final int n = nodeSensitivity.getNumberOfElements();
final DoubleMatrix2D inverseJacobian = MATRIX_ALGEBRA.getInverse(jacobian);
for (int i = 0; i < n; i++) {
double sum = 0;
for (int j = 0; j < n; j++) {
sum +=
-couponSensitivity.getEntry(i)
* inverseJacobian.getEntry(j, i)
* nodeSensitivity.getEntry(j);
}
resultList.add(sum);
}
}
return new DoubleMatrix1D(resultList.toDoubleArray());
}
/**
* Get the collection of values of this vector.
*
* @return The collection of all values in this vector.
*/
public DoubleCollection values() {
DoubleArrayList lst = new DoubleArrayList(size());
IntIterator iter = keys.activeIndexIterator(false);
while (iter.hasNext()) {
int idx = iter.nextInt();
lst.add(values[idx]);
}
return lst;
}
/**
* Implementation of {@link #build()} and {@link #finish()}.
*
* @param reuse Whether we should try to reuse the builder's storage for the packed list. If
* {@code true}, the builder will be invalid after finishing and the packed list will use the
* same arrays as the builder if they are full.
* @return The packed ID list.
*/
private PackedScoredIdList finish(boolean reuse) {
Preconditions.checkState(ids != null, "builder has been finished");
Map<Symbol, DoubleList> chans;
Map<TypedSymbol<?>, List<?>> typedChans;
if (size() > 0) {
ImmutableMap.Builder<Symbol, DoubleList> cbld = ImmutableMap.builder();
for (ChannelStorage chan : channels.values()) {
DoubleArrayList built;
if (reuse) {
built = chan.values;
built.trim();
} else {
built = new DoubleArrayList(chan.values);
}
cbld.put(chan.symbol, built);
}
chans = cbld.build();
ImmutableMap.Builder<TypedSymbol<?>, List<?>> tcbld = ImmutableMap.builder();
for (TypedChannelStorage<?> chan : typedChannels.values()) {
List<?> built;
if (reuse) {
chan.values.trimToSize();
built = chan.values;
} else {
built = new ArrayList<Object>(chan.values);
}
tcbld.put(chan.symbol, built);
}
typedChans = tcbld.build();
} else {
chans = Collections.emptyMap();
typedChans = Collections.emptyMap();
}
LongList builtIds;
DoubleList builtScores;
if (reuse) {
ids.trim();
builtIds = ids;
scores.trim();
builtScores = scores;
clear();
} else {
builtIds = new CompactableLongArrayList(ids);
builtScores = new DoubleArrayList(scores);
}
return new PackedScoredIdList(builtIds, builtScores, typedChans, chans);
}
public ChannelStorage(Symbol sym, double dft) {
symbol = sym;
defaultValue = dft;
values = new DoubleArrayList(scores.elements().length);
for (int i = size() - 1; i >= 0; i--) {
values.add(defaultValue);
}
}
public DoubleMatrix1D calculateFromSimpleInterpolatedCurve(
final Map<String, List<DoublesPair>> curveSensitivities,
final YieldCurveBundle interpolatedCurves) {
final DoubleArrayList resultList = new DoubleArrayList();
for (final String curveName : interpolatedCurves.getAllNames()) {
final DoubleMatrix1D nodeSensitivity =
new DoubleMatrix1D(
(_parameterSensitivityCalculator.pointToParameterSensitivity(
curveSensitivities.get(curveName), interpolatedCurves.getCurve(curveName)))
.toArray(new Double[0]));
final int n = nodeSensitivity.getNumberOfElements();
for (int i = 0; i < n; i++) {
double sum = 0;
for (int j = 0; j < n; j++) {
sum += nodeSensitivity.getEntry(j);
}
resultList.add(sum);
}
}
return new DoubleMatrix1D(resultList.toDoubleArray());
}
/**
* Add a scored ID without boxing. The default value will be used for each channel.
*
* @param id The ID to add.
* @param score The score for the ID.
* @return The builder (for chaining).
*/
public ScoredIdListBuilder add(long id, double score) {
Preconditions.checkState(ids != null, "builder has been finished");
ids.add(id);
scores.add(score);
for (ChannelStorage chan : channels.values()) {
assert chan.values.size() == ids.size() - 1;
chan.values.add(chan.defaultValue);
}
for (TypedChannelStorage chan : typedChannels.values()) {
assert chan.values.size() == ids.size() - 1;
chan.values.add(chan.defaultValue);
}
return this;
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final Clock snapshotClock = executionContext.getValuationClock();
final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
final Object volatilitySurfaceDataObject = inputs.getValue(_requirement);
if (volatilitySurfaceDataObject == null) {
throw new OpenGammaRuntimeException("Could not get " + _requirement);
}
@SuppressWarnings("unchecked")
final VolatilitySurfaceData<LocalDate, Double> volatilitySurfaceData =
(VolatilitySurfaceData<LocalDate, Double>) volatilitySurfaceDataObject;
final int n = volatilitySurfaceData.getXs().length;
final int m = volatilitySurfaceData.getYs().length;
final DoubleArrayList t = new DoubleArrayList();
final DoubleArrayList k = new DoubleArrayList();
final DoubleArrayList sigma = new DoubleArrayList();
final LocalDate[] xDates = volatilitySurfaceData.getXs();
final Double[] y = volatilitySurfaceData.getYs();
for (int i = 0; i < n; i++) {
final Double time = DateUtils.getDifferenceInYears(now.toLocalDate(), xDates[i]);
for (int j = 0; j < m; j++) {
final Double strike = y[j];
final Double vol = volatilitySurfaceData.getVolatility(xDates[i], y[j]);
if (time != null && strike != null && vol != null) {
t.add(time);
k.add(strike);
sigma.add(vol);
}
}
}
final Surface<Double, Double, Double> surface =
InterpolatedDoublesSurface.from(
t.toDoubleArray(), k.toDoubleArray(), sigma.toDoubleArray(), _interpolator);
final VolatilitySurface volatilitySurface = new VolatilitySurface(surface);
return Collections.singleton(new ComputedValue(_result, volatilitySurface));
}
/**
* Add a scored ID. The ID is copied into the builder, not referenced. All side channels on the ID
* must have already been added with one of the {@code addChannel} methods.
*
* @param id The ID.
* @return The builder (for chaining).
*/
public ScoredIdListBuilder add(ScoredId id) {
Preconditions.checkState(ids != null, "builder has been finished");
// check whether all symbols are valid
Collection<SymbolValue<?>> chans = id.getChannels();
if (!ignoreUnknown) {
for (SymbolValue<?> chan : chans) {
TypedSymbol<?> sym = chan.getSymbol();
boolean good =
sym.getType().equals(Double.class)
? channels.containsKey(sym.getRawSymbol())
: typedChannels.containsKey(sym);
if (!good) {
throw new IllegalArgumentException("channel " + sym + " not known");
}
}
}
// now we're ready to add
int idx = ids.size();
add(id.getId(), id.getScore());
assert ids.size() == idx + 1;
assert scores.size() == idx + 1;
for (SymbolValue<?> sv : chans) {
TypedSymbol<?> sym = sv.getSymbol();
if (sym.getType().equals(Double.class) && channels.containsKey(sym.getRawSymbol())) {
ChannelStorage chan = channels.get(sym.getRawSymbol());
assert chan.values.size() == idx + 1;
if (sv instanceof DoubleSymbolValue) {
chan.values.set(idx, ((DoubleSymbolValue) sv).getDoubleValue());
} else {
Object v = sv.getValue();
chan.values.set(idx, (Double) v);
}
} else {
TypedChannelStorage chan = typedChannels.get(sv.getSymbol());
if (chan != null) {
assert chan.values.size() == idx + 1;
chan.values.set(idx, sv.getValue());
}
}
}
return this;
}
@Override
public void seal() {
((DoubleArrayList) _innerList).trim();
_elements = ((DoubleArrayList) _innerList).elements();
int negativeIndexCheck = 1;
// reverse negative elements, because string order and numeric orders are completely opposite
if (_elements.length > negativeIndexCheck && _elements[negativeIndexCheck] < 0) {
int endPosition = indexOfWithType((short) 0);
if (endPosition < 0) {
endPosition = -1 * endPosition - 1;
}
double tmp;
for (int i = 0; i < (endPosition - negativeIndexCheck) / 2; i++) {
tmp = _elements[i + negativeIndexCheck];
_elements[i + negativeIndexCheck] = _elements[endPosition - i - 1];
_elements[endPosition - i - 1] = tmp;
}
}
}
/**
* Build a sparse vector directly from the list of IDs. This allows a scored ID list builder to be
* used to efficiently accumulate a sparse vector. If the same ID is added multiple times, the
* first instance is used.
*
* @return A sparse vector containing the data accumulated.
*/
public ImmutableSparseVector buildVector() {
MutableSparseVector msv = MutableSparseVector.create(ids);
final int size = size();
for (int i = 0; i < size; i++) {
msv.set(ids.get(i), scores.get(i));
}
for (ChannelStorage chan : channels.values()) {
MutableSparseVector vchan = msv.getOrAddChannelVector(chan.symbol);
for (int i = 0; i < size; i++) {
vchan.set(ids.get(i), chan.values.get(i));
}
}
for (TypedChannelStorage<?> chan : typedChannels.values()) {
Long2ObjectMap vchan = msv.getOrAddChannel(chan.symbol);
for (int i = 0; i < size; i++) {
vchan.put(ids.get(i), chan.values.get(i));
}
}
return msv.freeze();
}
public static void main(final String[] arg)
throws IOException, JSAPException, ConfigurationException, ClassNotFoundException {
SimpleJSAP jsap =
new SimpleJSAP(
WeightedPageRankPowerMethod.class.getName(),
"Computes PageRank of a graph with given graphBasename using the power method."
+ "The resulting doubles are stored in binary form in rankFile."
+ "\n[STOPPING CRITERION] The computation is stopped as soon as two successive iterates have"
+ "an L2-distance smaller than a given threshold (-t option); in any case no more than a fixed"
+ "number of iterations (-i option) is performed.",
new Parameter[] {
new FlaggedOption(
"alpha",
JSAP.DOUBLE_PARSER,
Double.toString(WeightedPageRank.DEFAULT_ALPHA),
JSAP.NOT_REQUIRED,
'a',
"alpha",
"Damping factor."),
new FlaggedOption(
"maxIter",
JSAP.INTEGER_PARSER,
Integer.toString(WeightedPageRank.DEFAULT_MAX_ITER),
JSAP.NOT_REQUIRED,
'i',
"max-iter",
"Maximum number of iterations."),
new FlaggedOption(
"threshold",
JSAP.DOUBLE_PARSER,
Double.toString(WeightedPageRank.DEFAULT_THRESHOLD),
JSAP.NOT_REQUIRED,
't',
"threshold",
"Threshold to determine whether to stop."),
new FlaggedOption(
"coeff",
JSAP.STRING_PARSER,
JSAP.NO_DEFAULT,
JSAP.NOT_REQUIRED,
'c',
"coeff",
"Save the k-th coefficient of the Taylor polynomial using this basename."),
new FlaggedOption(
"derivative",
JSAP.INTEGER_PARSER,
JSAP.NO_DEFAULT,
JSAP.NOT_REQUIRED,
'd',
"derivative",
"The order(s) of the the derivative(s) to be computed (>0).")
.setAllowMultipleDeclarations(true),
new FlaggedOption(
"preferenceVector",
JSAP.STRING_PARSER,
JSAP.NO_DEFAULT,
JSAP.NOT_REQUIRED,
'p',
"preference-vector",
"A preference vector stored as a vector of binary doubles."),
new FlaggedOption(
"preferenceObject",
JSAP.STRING_PARSER,
JSAP.NO_DEFAULT,
JSAP.NOT_REQUIRED,
'P',
"preference-object",
"A preference vector stored as a serialised DoubleList."),
new FlaggedOption(
"startFilename",
JSAP.STRING_PARSER,
JSAP.NO_DEFAULT,
JSAP.NOT_REQUIRED,
'1',
"start",
"Start vector filename."),
new FlaggedOption(
"buckets",
JSAP.STRING_PARSER,
JSAP.NO_DEFAULT,
JSAP.NOT_REQUIRED,
'b',
"buckets",
"The buckets of the graph; if supplied, buckets will be treated as dangling nodes."),
new Switch("offline", 'o', "offline", "use loadOffline() to load the graph"),
new Switch(
"strongly",
'S',
"strongly",
"use the preference vector to redistribute the dangling rank."),
new Switch(
"sortedRank",
's',
"sorted-ranks",
"Store the ranks (from highest to lowest) into <rankBasename>-sorted.ranks."),
new FlaggedOption(
"norm",
JSAP.STRING_PARSER,
WeightedPageRank.Norm.INFTY.toString(),
JSAP.NOT_REQUIRED,
'n',
"norm",
"Norm type. Possible values: " + Arrays.toString(WeightedPageRank.Norm.values())),
new UnflaggedOption(
"graphBasename",
JSAP.STRING_PARSER,
JSAP.NO_DEFAULT,
JSAP.REQUIRED,
JSAP.NOT_GREEDY,
"The basename of the graph."),
new UnflaggedOption(
"rankBasename",
JSAP.STRING_PARSER,
JSAP.NO_DEFAULT,
JSAP.REQUIRED,
JSAP.NOT_GREEDY,
"The filename where the resulting rank (doubles in binary form) are stored.")
});
JSAPResult jsapResult = jsap.parse(arg);
if (jsap.messagePrinted()) return;
final boolean offline = jsapResult.getBoolean("offline", false);
final boolean strongly = jsapResult.getBoolean("strongly", false);
final boolean sorted = jsapResult.getBoolean("sortedRank", false);
final int[] order = jsapResult.getIntArray("derivative");
final String graphBasename = jsapResult.getString("graphBasename");
final String rankBasename = jsapResult.getString("rankBasename");
final String buckets = jsapResult.getString("buckets");
final String startFilename = jsapResult.getString("startFilename", null);
final String coeffBasename = jsapResult.getString("coeff");
final String norm = jsapResult.getString("norm");
final ProgressLogger progressLogger = new ProgressLogger(LOGGER, "nodes");
ArcLabelledImmutableGraph graph =
offline
? ArcLabelledImmutableGraph.loadOffline(graphBasename, progressLogger)
: ArcLabelledImmutableGraph.loadSequential(graphBasename, progressLogger);
DoubleList preference = null;
String preferenceFilename = null;
if (jsapResult.userSpecified("preferenceVector"))
preference =
DoubleArrayList.wrap(
BinIO.loadDoubles(preferenceFilename = jsapResult.getString("preferenceVector")));
if (jsapResult.userSpecified("preferenceObject")) {
if (jsapResult.userSpecified("preferenceVector"))
throw new IllegalArgumentException("You cannot specify twice the preference vector");
preference =
(DoubleList)
BinIO.loadObject(preferenceFilename = jsapResult.getString("preferenceObject"));
}
if (strongly && preference == null)
throw new IllegalArgumentException("The 'strongly' option requires a preference vector");
DoubleList start = null;
if (startFilename != null) {
LOGGER.debug("Loading start vector \"" + startFilename + "\"...");
start = DoubleArrayList.wrap(BinIO.loadDoubles(startFilename));
LOGGER.debug("done.");
}
WeightedPageRankPowerMethod pr = new WeightedPageRankPowerMethod(graph);
pr.alpha = jsapResult.getDouble("alpha");
pr.preference = preference;
pr.buckets = (BitSet) (buckets == null ? null : BinIO.loadObject(buckets));
pr.stronglyPreferential = strongly;
pr.start = start;
pr.norm = WeightedPageRank.Norm.valueOf(norm);
pr.order = order != null ? order : null;
pr.coeffBasename = coeffBasename;
// cycle until we reach maxIter interations or the norm is less than the given threshold
// (whichever comes first)
pr.stepUntil(
or(
new WeightedPageRank.NormDeltaStoppingCriterion(jsapResult.getDouble("threshold")),
new WeightedPageRank.IterationNumberStoppingCriterion(jsapResult.getInt("maxIter"))));
System.err.print("Saving ranks...");
BinIO.storeDoubles(pr.rank, rankBasename + ".ranks");
if (pr.numNodes < 100) {
for (int i = 0; i < pr.rank.length; i++) {
System.err.println("PageRank[" + i + "]=" + pr.rank[i]);
}
}
Properties prop = pr.buildProperties(graphBasename, preferenceFilename, startFilename);
prop.save(rankBasename + ".properties");
if (order != null) {
System.err.print("Saving derivatives...");
for (int i = 0; i < order.length; i++)
BinIO.storeDoubles(pr.derivative[i], rankBasename + ".der-" + order[i]);
}
final double[] rank = pr.rank;
pr = null; // Let us free some memory...
graph = null;
if (sorted) {
System.err.print("Sorting ranks...");
Arrays.sort(rank);
final int n = rank.length;
int i = n / 2;
double t;
// Since we need the ranks from highest to lowest, we invert their order.
while (i-- != 0) {
t = rank[i];
rank[i] = rank[n - i - 1];
rank[n - i - 1] = t;
}
System.err.print(" saving sorted ranks...");
BinIO.storeDoubles(rank, rankBasename + "-sorted.ranks");
System.err.println(" done.");
}
}
/**
* Get the number of items currently in the builder.
*
* @return The number of items in the builder.
*/
public int size() {
assert ids.size() == scores.size();
return ids.size();
}
