protected FXForwardSecurity createFXForwardSecurity(final Bundle bundle) {
   final double putAmount = bundle._firstCurrency.equals(Currency.JPY) ? NOTIONAL * 100 : NOTIONAL;
   final ZonedDateTime forwardDate =
       nextWorkingDay(
           bundle._tradeDate.plusDays(bundle._daysOffset),
           bundle._firstCurrency,
           bundle._secondCurrency);
   final Double fxRate =
       getApproxFXRate(
           forwardDate.toLocalDate(), Pair.of(bundle._firstCurrency, bundle._secondCurrency));
   if (fxRate == null) {
     return null;
   }
   final double callAmount = NOTIONAL * fxRate;
   final Currency payCurrency = bundle._long ? bundle._secondCurrency : bundle._firstCurrency;
   final Currency receiveCurrency = bundle._long ? bundle._firstCurrency : bundle._secondCurrency;
   final String dateString = forwardDate.toString(DATE_FORMATTER);
   final FXForwardSecurity fxForwardSecurity =
       new FXForwardSecurity(
           payCurrency, callAmount, receiveCurrency, putAmount, forwardDate, REGION);
   final String callAmountString = NOTIONAL_FORMATTER.format(callAmount);
   final String putAmountString = NOTIONAL_FORMATTER.format(putAmount);
   fxForwardSecurity.setName(
       "Pay "
           + payCurrency
           + " "
           + callAmountString
           + ", receive "
           + receiveCurrency
           + " "
           + putAmountString
           + " on "
           + dateString);
   return fxForwardSecurity;
 }
 protected FXDigitalOptionSecurity createFXDigitalOptionSecurity(final Bundle bundle) {
   final Currency putCurrency = bundle._firstCurrency;
   final Currency callCurrency = bundle._secondCurrency;
   final Currency paymentCurrency = bundle._paymentCurrency;
   final double putAmount = putCurrency.equals(Currency.JPY) ? NOTIONAL * 100 : NOTIONAL;
   final ZonedDateTime expiry =
       nextWorkingDay(bundle._tradeDate.plusDays(bundle._daysOffset), putCurrency, callCurrency);
   final Double rate = getApproxFXRate(expiry.toLocalDate(), Pair.of(putCurrency, callCurrency));
   if (rate == null) {
     return null;
   }
   final double callAmount = rate * NOTIONAL;
   final ZonedDateTime settlementDate =
       nextWorkingDay(expiry.plusDays(2), putCurrency, callCurrency);
   final FXDigitalOptionSecurity security =
       new FXDigitalOptionSecurity(
           putCurrency,
           callCurrency,
           putAmount,
           callAmount,
           paymentCurrency,
           new Expiry(expiry),
           settlementDate,
           bundle._long);
   final StringBuilder sb = new StringBuilder("Digital ");
   sb.append(bundle._long ? "Long" : "Short");
   sb.append(" put ").append(putCurrency).append(' ').append(NOTIONAL_FORMATTER.format(putAmount));
   sb.append(", call ")
       .append(callCurrency)
       .append(' ')
       .append(NOTIONAL_FORMATTER.format(callAmount));
   sb.append(" on ").append(expiry.toString(DATE_FORMATTER));
   security.setName(sb.toString());
   return security;
 }
 protected FXBarrierOptionSecurity createFXBarrierOptionSecurity(final Bundle bundle) {
   final Currency putCurrency = bundle._firstCurrency;
   final Currency callCurrency = bundle._secondCurrency;
   final double putAmount = putCurrency.equals(Currency.JPY) ? NOTIONAL * 100 : NOTIONAL;
   final ZonedDateTime settlementDate =
       nextWorkingDay(
           bundle._tradeDate.plusDays(bundle._daysOffset),
           bundle._firstCurrency,
           bundle._secondCurrency);
   final Expiry expiry = new Expiry(settlementDate, ExpiryAccuracy.DAY_MONTH_YEAR);
   final Double fxRate =
       getApproxFXRate(
           settlementDate.toLocalDate(), Pair.of(bundle._firstCurrency, bundle._secondCurrency));
   if (fxRate == null) {
     return null;
   }
   final double callAmount = NOTIONAL * fxRate;
   final String dateString = settlementDate.toString(DATE_FORMATTER);
   final BarrierType barrierType = bundle._up ? BarrierType.UP : BarrierType.DOWN;
   final BarrierDirection barrierDirection = BarrierDirection.KNOCK_IN;
   final MonitoringType monitoringType = MonitoringType.CONTINUOUS;
   final SamplingFrequency samplingFrequency = SamplingFrequency.DAILY_CLOSE;
   final double barrierLevel = bundle._up ? fxRate * 1.5 : fxRate / 1.5;
   final FXBarrierOptionSecurity fxBarrierOptionSecurity =
       new FXBarrierOptionSecurity(
           putCurrency,
           callCurrency,
           putAmount,
           callAmount,
           expiry,
           settlementDate,
           barrierType,
           barrierDirection,
           monitoringType,
           samplingFrequency,
           barrierLevel,
           bundle._long);
   final String callAmountString = NOTIONAL_FORMATTER.format(callAmount);
   final String putAmountString = NOTIONAL_FORMATTER.format(putAmount);
   final String barrierLevelString = RATE_FORMATTER.format(barrierLevel);
   final String barrierUnitString = callCurrency + "/" + putCurrency;
   fxBarrierOptionSecurity.setName(
       (bundle._long ? "Long " : "Short ")
           + (bundle._up ? "up" : "down")
           + " knock-in at "
           + barrierLevelString
           + " "
           + barrierUnitString
           + ", put "
           + putCurrency
           + " "
           + putAmountString
           + ", call "
           + callCurrency
           + " "
           + callAmountString
           + " on "
           + dateString);
   return fxBarrierOptionSecurity;
 }
Exemplo n.º 4
0
 /**
  * Entry point from the service wrapper - starts a connection handler for a given client.
  *
  * @param userName the user name of the incoming connection
  * @param inputPipeName the pipe created for sending data from C++ to Java
  * @param outputPipeName the pipe created for sending data from Java to C++
  * @param languageID the identifier of the bound language. Language specific factories will be
  *     used if present, otherwise the default factories will be used.
  * @param debug true if the bound language is a debug build
  * @return true if the connection started okay
  */
 public static synchronized boolean svcAccept(
     final String userName,
     final String inputPipeName,
     final String outputPipeName,
     final String languageID,
     final boolean debug) {
   try {
     s_logger.info("Accepted {} connection from {}", languageID, userName);
     s_logger.debug("Using pipes IN:{} OUT:{}", inputPipeName, outputPipeName);
     final Pair<ClientFactory, SessionContextFactory> factories =
         s_springContext.getLanguageFactories(languageID);
     final SessionContext sessionContext =
         factories.getSecond().createSessionContext(userName, debug);
     final Client client =
         factories.getFirst().createClient(inputPipeName, outputPipeName, sessionContext);
     s_activeConnections++;
     s_executorService.submit(
         new Runnable() {
           @Override
           public void run() {
             client.run();
             s_logger.info("Session for {} disconnected", userName);
             clientDisconnected();
           }
         });
     return true;
   } catch (Throwable t) {
     s_logger.error("Exception thrown", t);
     return false;
   }
 }
  /* package */ void updateDepGraphCells(Set<WebGridCell> newCells) {
    Set<WebGridCell> currentCells = _depGraphGrids.keySet();
    Set<WebGridCell> cellsToRemove = Sets.difference(currentCells, newCells);
    Set<WebGridCell> cellsToAdd = Sets.difference(newCells, currentCells);

    for (WebGridCell cell : cellsToRemove) {
      _depGraphGrids.remove(cell);
    }
    for (WebGridCell cell : cellsToAdd) {
      String gridName = getName() + ".depgraph-" + cell.getRowId() + "-" + cell.getColumnId();
      OperationTimer timer = new OperationTimer(s_logger, "depgraph");
      Pair<String, ValueSpecification> columnMappingPair =
          getGridStructure()
              .findCellSpecification(cell, getViewClient().getLatestCompiledViewDefinition());
      s_logger.debug("includeDepGraph took {}", timer.finished());
      // TODO should this ever happen? it is currently
      if (columnMappingPair != null) {
        PushWebViewDepGraphGrid grid =
            new PushWebViewDepGraphGrid(
                gridName,
                getViewClient(),
                getConverterCache(),
                cell,
                columnMappingPair.getFirst(),
                columnMappingPair.getSecond());
        _depGraphGrids.put(cell, grid);
      }
    }
  }
Exemplo n.º 6
0
 private static void populateVolatilitySurfaceDefinitions(
     final ConfigMaster configMaster, final UniqueIdentifiable target) {
   final Tenor[] expiryTenors =
       new Tenor[] {
         Tenor.ofDays(7),
         Tenor.ofDays(14),
         Tenor.ofDays(21),
         Tenor.ofMonths(1),
         Tenor.ofMonths(3),
         Tenor.ofMonths(6),
         Tenor.ofMonths(9),
         Tenor.ofYears(1),
         Tenor.ofYears(5),
         Tenor.ofYears(10)
       };
   @SuppressWarnings("unchecked")
   final Pair<Number, FXVolQuoteType>[] deltaAndTypes =
       new Pair[] {
         Pair.of(25, FXVolQuoteType.BUTTERFLY),
         Pair.of(25, FXVolQuoteType.RISK_REVERSAL),
         Pair.of(15, FXVolQuoteType.BUTTERFLY),
         Pair.of(15, FXVolQuoteType.RISK_REVERSAL),
         Pair.of(0, FXVolQuoteType.ATM)
       };
   final VolatilitySurfaceDefinition<Tenor, Pair<Number, FXVolQuoteType>> volSurfaceDefinition =
       new VolatilitySurfaceDefinition<Tenor, Pair<Number, FXVolQuoteType>>(
           "SECONDARY_EURUSD_" + InstrumentTypeProperties.FOREX,
           target,
           expiryTenors,
           deltaAndTypes);
   ConfigMasterUtils.storeByName(configMaster, makeConfigDocument(volSurfaceDefinition));
 }
Exemplo n.º 7
0
 public static VolatilityAndBucketedSensitivities getVolatilityAndSensitivities(
     final SmileDeltaTermStructureDataBundle data,
     final Currency ccy1,
     final Currency ccy2,
     final double time,
     final double strike,
     final double forward) {
   ArgumentChecker.notNull(ccy1, "ccy1");
   ArgumentChecker.notNull(ccy2, "ccy2");
   ArgumentChecker.notNull(data, "data");
   final Pair<Currency, Currency> currencyPair = data.getCurrencyPair();
   final SmileDeltaTermStructureParametersStrikeInterpolation smile = data.getVolatilityModel();
   if ((ccy1 == currencyPair.getFirst()) && (ccy2 == currencyPair.getSecond())) {
     return smile.getVolatilityAndSensitivities(time, strike, forward);
   }
   if ((ccy2 == currencyPair.getFirst()) && (ccy1 == currencyPair.getSecond())) {
     return smile.getVolatilityAndSensitivities(time, 1.0 / strike, 1.0 / forward);
   }
   throw new IllegalArgumentException(
       "Currencies not compatible with smile data; asked for "
           + ccy1
           + " and "
           + ccy2
           + ", have "
           + data.getCurrencyMap().values());
 }
Exemplo n.º 8
0
 /**
  * Creates the output root data.
  *
  * @return the output root data, not null
  */
 protected FlexiBean createRootData() {
   FlexiBean out = super.createRootData();
   HolidayDocument latestDoc = data().getHoliday();
   HolidayDocument versionedHoliday = data().getVersioned();
   out.put("latestHolidayDoc", latestDoc);
   out.put("latestHoliday", latestDoc.getHoliday());
   out.put("holidayDoc", versionedHoliday);
   out.put("holiday", versionedHoliday.getHoliday());
   out.put("deleted", !latestDoc.isLatest());
   List<Pair<Year, List<LocalDate>>> map = new ArrayList<Pair<Year, List<LocalDate>>>();
   List<LocalDate> dates = versionedHoliday.getHoliday().getHolidayDates();
   if (dates.size() > 0) {
     int year = dates.get(0).getYear();
     int start = 0;
     int pos = 0;
     for (; pos < dates.size(); pos++) {
       if (dates.get(pos).getYear() == year) {
         continue;
       }
       map.add(Pair.of(Year.of(year), dates.subList(start, pos)));
       year = dates.get(pos).getYear();
       start = pos;
     }
     map.add(Pair.of(Year.of(year), dates.subList(start, pos)));
   }
   out.put("holidayDatesByYear", map);
   return out;
 }
  private static List<RequirementBasedColumnKey> getRequirements(
      ViewDefinition viewDefinition, EnumSet<ComputationTargetType> targetTypes) {
    List<RequirementBasedColumnKey> result = new ArrayList<RequirementBasedColumnKey>();
    for (ViewCalculationConfiguration calcConfig :
        viewDefinition.getAllCalculationConfigurations()) {
      String calcConfigName = calcConfig.getName();
      if (targetTypes.contains(ComputationTargetType.POSITION)
          || targetTypes.contains(ComputationTargetType.PORTFOLIO_NODE)) {
        for (Pair<String, ValueProperties> portfolioOutput :
            calcConfig.getAllPortfolioRequirements()) {
          String valueName = portfolioOutput.getFirst();
          ValueProperties constraints = portfolioOutput.getSecond();
          RequirementBasedColumnKey columnKey =
              new RequirementBasedColumnKey(calcConfigName, valueName, constraints);
          result.add(columnKey);
        }
      }

      for (ValueRequirement specificRequirement : calcConfig.getSpecificRequirements()) {
        if (!targetTypes.contains(specificRequirement.getTargetSpecification().getType())) {
          continue;
        }
        String valueName = specificRequirement.getValueName();
        ValueProperties constraints = specificRequirement.getConstraints();
        RequirementBasedColumnKey columnKey =
            new RequirementBasedColumnKey(calcConfigName, valueName, constraints);
        result.add(columnKey);
      }
    }
    return result;
  }
 @BeforeClass
 public void createServer() throws Exception {
   Pair<Server, WebApplicationContext> serverAndContext =
       _webPushTestUtils.createJettyServer(
           "classpath:/com/opengamma/web/analytics/push/rest-subscription-test.xml");
   _server = serverAndContext.getFirst();
   WebApplicationContext context = serverAndContext.getSecond();
   _positionChangeManager = context.getBean("positionChangeManager", TestChangeManager.class);
 }
 private ResolutionIterator(final Pair<?, ?> values) {
   _properties = values.getFirst();
   _functions = values.getSecond();
   if (_properties instanceof ValueProperties) {
     _length = 1;
   } else {
     _length = ((ValueProperties[]) _properties).length;
   }
   _index = 0;
 }
 @Override
 public CurveBuildingBlockBundle buildObject(
     final FudgeDeserializer deserializer, final FudgeMsg message) {
   final List<FudgeField> curveNames = message.getAllByName(CURVE_NAME_FIELD);
   final List<FudgeField> blocks = message.getAllByName(BLOCK_FIELD);
   final List<FudgeField> matrices = message.getAllByName(MATRIX_FIELD);
   final int n = curveNames.size();
   if (blocks.size() != n) {
     throw new IllegalStateException(
         "Should have one block for each curve name; have " + curveNames + " and " + blocks);
   }
   if (matrices.size() != n) {
     throw new IllegalStateException(
         "Should have one matrix for each curve name; have " + curveNames + " and " + matrices);
   }
   final LinkedHashMap<String, Pair<CurveBuildingBlock, DoubleMatrix2D>> data =
       new LinkedHashMap<>();
   for (int i = 0; i < n; i++) {
     final String curveName = (String) curveNames.get(i).getValue();
     final CurveBuildingBlock block =
         deserializer.fieldValueToObject(CurveBuildingBlock.class, blocks.get(i));
     final DoubleMatrix2D m =
         new DoubleMatrix2D(deserializer.fieldValueToObject(double[][].class, matrices.get(i)));
     data.put(curveName, Pair.of(block, m));
   }
   return new CurveBuildingBlockBundle(data);
 }
 @Override
 public synchronized YieldCurveDefinitionDocument update(YieldCurveDefinitionDocument document) {
   ArgumentChecker.notNull(document, "document");
   ArgumentChecker.notNull(document.getYieldCurveDefinition(), "document.yieldCurveDefinition");
   final Currency currency = document.getYieldCurveDefinition().getCurrency();
   final String name = document.getYieldCurveDefinition().getName();
   final UniqueId uid = UniqueId.of(getUniqueIdScheme(), name + "_" + currency.getCode());
   if (!uid.equals(document.getUniqueId())) {
     throw new IllegalArgumentException("Invalid unique identifier");
   }
   final Pair<Currency, String> key = Pair.of(currency, name);
   final TreeMap<Instant, YieldCurveDefinition> value = _definitions.get(key);
   if (value == null) {
     throw new DataNotFoundException("UID '" + uid + "' not found");
   }
   if (_sourceVersionCorrection.getVersionAsOf() != null) {
     // Don't need to keep the old values before the one needed by "versionAsOfInstant"
     final Instant oldestNeeded = value.floorKey(_sourceVersionCorrection.getVersionAsOf());
     value.headMap(oldestNeeded).clear();
   } else {
     // Don't need any old values
     value.clear();
   }
   Instant now = Instant.now();
   value.put(now, document.getYieldCurveDefinition());
   document.setUniqueId(uid);
   changeManager().entityChanged(ChangeType.CHANGED, uid.getObjectId(), null, null, now);
   return document;
 }
 @Override
 public synchronized YieldCurveDefinitionDocument get(
     ObjectIdentifiable objectIdable, VersionCorrection versionCorrection) {
   ArgumentChecker.notNull(objectIdable, "objectIdable");
   ObjectId objectId = objectIdable.getObjectId();
   if (!getUniqueIdScheme().equals(objectId.getScheme())) {
     throw new DataNotFoundException(
         "Scheme '" + objectId.getScheme() + "' not valid for '" + getUniqueIdScheme() + "'");
   }
   final int i = objectId.getValue().indexOf('_');
   if (i <= 0) {
     throw new DataNotFoundException(
         "Identifier '" + objectId.getValue() + "' not valid for '" + getUniqueIdScheme() + "'");
   }
   final String name = objectId.getValue().substring(0, i);
   final String iso = objectId.getValue().substring(i + 1);
   final Currency currency;
   try {
     currency = Currency.of(iso);
   } catch (IllegalArgumentException e) {
     throw new DataNotFoundException(
         "Identifier '" + objectId.getValue() + "' not valid for '" + getUniqueIdScheme() + "'",
         e);
   }
   final TreeMap<Instant, YieldCurveDefinition> definitions =
       _definitions.get(Pair.of(currency, name));
   if (definitions == null) {
     throw new DataNotFoundException("Curve definition not found");
   }
   final YieldCurveDefinition definition = definitions.lastEntry().getValue();
   if (definition == null) {
     throw new DataNotFoundException("Curve definition not found");
   }
   return new YieldCurveDefinitionDocument(objectId.atLatestVersion(), definition);
 }
 // -------------------------------------------------------------------------
 @Override
 public synchronized YieldCurveDefinitionDocument add(YieldCurveDefinitionDocument document) {
   ArgumentChecker.notNull(document, "document");
   ArgumentChecker.notNull(document.getYieldCurveDefinition(), "document.yieldCurveDefinition");
   final Currency currency = document.getYieldCurveDefinition().getCurrency();
   final String name = document.getYieldCurveDefinition().getName();
   final Pair<Currency, String> key = Pair.of(currency, name);
   if (_definitions.containsKey(key)) {
     throw new IllegalArgumentException("Duplicate definition");
   }
   final TreeMap<Instant, YieldCurveDefinition> value =
       new TreeMap<Instant, YieldCurveDefinition>();
   Instant now = Instant.now();
   value.put(now, document.getYieldCurveDefinition());
   _definitions.put(key, value);
   final UniqueId uid = UniqueId.of(getUniqueIdScheme(), name + "_" + currency.getCode());
   document.setUniqueId(uid);
   changeManager()
       .entityChanged(
           ChangeType.ADDED,
           document.getObjectId(),
           document.getVersionFromInstant(),
           document.getVersionToInstant(),
           now);
   return document;
 }
 @Override
 public CurveBuildingBlock buildObject(
     final FudgeDeserializer deserializer, final FudgeMsg message) {
   final List<FudgeField> curveNames = message.getAllByName(CURVE_NAME_FIELD);
   final List<FudgeField> startIndices = message.getAllByName(START_INDEX_FIELD);
   final int n = curveNames.size();
   if (startIndices.size() != n) {
     throw new IllegalStateException(
         "Should have one start index for each curve name; have "
             + curveNames
             + " and "
             + startIndices);
   }
   final List<FudgeField> numbers = message.getAllByName(NUMBER_FIELD);
   if (numbers.size() != n) {
     throw new IllegalStateException(
         "Should have one parameter number for each curve name; have "
             + curveNames
             + " and "
             + numbers);
   }
   final LinkedHashMap<String, Pair<Integer, Integer>> data = new LinkedHashMap<>();
   for (int i = 0; i < n; i++) {
     final String curveName = (String) curveNames.get(i).getValue();
     final Integer startIndex = ((Number) startIndices.get(i).getValue()).intValue();
     final Integer number = ((Number) numbers.get(i).getValue()).intValue();
     data.put(curveName, Pair.of(startIndex, number));
   }
   return new CurveBuildingBlock(data);
 }
Exemplo n.º 17
0
  @SuppressWarnings("unchecked")
  @Test
  public void expandedRectangular() {
    Tenor[] xVals = new Tenor[] {Tenor.DAY, Tenor.ONE_WEEK, Tenor.TWO_WEEKS};
    Tenor[] yVals = new Tenor[] {Tenor.ONE_YEAR, Tenor.TWO_YEARS};
    double[] vols = new double[] {10, 11, 12, 13, 14, 15};
    Map<Pair<Tenor, Tenor>, Double> vol = Maps.newHashMap();
    for (int y = 0; y < yVals.length; y++) {
      for (int x = 0; x < xVals.length; x++) {
        vol.put(Pair.of(xVals[x], yVals[y]), vols[x + (y * xVals.length)]);
      }
    }
    String name = "test";
    UniqueIdentifiable target = Currency.USD;
    VolatilitySurfaceData<Tenor, Tenor> data =
        new VolatilitySurfaceData<>(name, name, target, xVals, yVals, vol);

    Map<String, Object> map =
        (Map<String, Object>)
            new VolatilitySurfaceDataFormatter()
                .format(data, null, TypeFormatter.Format.EXPANDED, null);
    assertEquals(Lists.newArrayList("1D", "7D", "14D"), map.get(SurfaceFormatterUtils.X_LABELS));
    assertEquals(Lists.newArrayList("1Y", "2Y"), map.get(SurfaceFormatterUtils.Y_LABELS));
    assertEquals(
        Lists.newArrayList(10d, 11d, 12d, 13d, 14d, 15d), map.get(SurfaceFormatterUtils.VOL));
  }
Exemplo n.º 18
0
  @SuppressWarnings("unchecked")
  @Test
  public void expandedRagged() {
    Tenor[] xs =
        new Tenor[] {Tenor.DAY, Tenor.ONE_WEEK, Tenor.TWO_WEEKS, Tenor.TWO_WEEKS, Tenor.ONE_MONTH};
    Tenor[] ys =
        new Tenor[] {
          Tenor.ONE_YEAR, Tenor.ONE_YEAR, Tenor.ONE_YEAR, Tenor.TWO_YEARS, Tenor.TWO_YEARS
        };
    double[] vols = new double[] {10, 11, 12, 13, 14};
    Map<Pair<Tenor, Tenor>, Double> values = Maps.newHashMap();
    for (int i = 0; i < xs.length; i++) {
      values.put(Pair.of(xs[i], ys[i]), vols[i]);
    }
    String name = "test";
    UniqueIdentifiable target = Currency.USD;
    VolatilitySurfaceData<Tenor, Tenor> data =
        new VolatilitySurfaceData<>(name, name, target, xs, ys, values);

    Map<String, Object> map =
        (Map<String, Object>)
            new VolatilitySurfaceDataFormatter()
                .format(data, null, TypeFormatter.Format.EXPANDED, null);
    assertEquals(
        Lists.newArrayList("1D", "7D", "14D", "1M"), map.get(SurfaceFormatterUtils.X_LABELS));
    assertEquals(Lists.newArrayList("1Y", "2Y"), map.get(SurfaceFormatterUtils.Y_LABELS));
    assertEquals(
        Lists.newArrayList(10d, 11d, 12d, null, null, null, 13d, 14d),
        map.get(SurfaceFormatterUtils.VOL));
  }
 @SuppressWarnings("unchecked")
 public Pair<ResolveTask[], ResolvedValueProducer[]> getTasksProducing(
     final ValueSpecification valueSpecification) {
   do {
     final MapEx<ResolveTask, ResolvedValueProducer> tasks =
         getBuilder().getTasks(valueSpecification);
     if (tasks != null) {
       final ResolveTask[] resultTasks;
       final ResolvedValueProducer[] resultProducers;
       synchronized (tasks) {
         if (tasks.containsKey(null)) {
           continue;
         }
         if (tasks.isEmpty()) {
           return null;
         }
         resultTasks = new ResolveTask[tasks.size()];
         resultProducers = new ResolvedValueProducer[tasks.size()];
         int i = 0;
         for (final Map.Entry<ResolveTask, ResolvedValueProducer> task :
             (Set<Map.Entry<ResolveTask, ResolvedValueProducer>>) tasks.entrySet()) {
           // Don't ref-count the tasks; they're just used for parent comparisons
           resultTasks[i] = task.getKey();
           resultProducers[i++] = task.getValue();
           task.getValue().addRef(); // We're holding the task lock
         }
       }
       return Pair.of(resultTasks, resultProducers);
     } else {
       return null;
     }
   } while (true);
 }
Exemplo n.º 20
0
 public static String getFormattedStrike(
     final double strike, final Pair<Currency, Currency> pair) {
   if (pair.getFirst().compareTo(pair.getSecond()) < 0) {
     return STRIKE_FORMATTER.format(strike) + " " + pair.getFirst() + "/" + pair.getSecond();
   }
   if (pair.getFirst().compareTo(pair.getSecond()) > 0) {
     return STRIKE_FORMATTER.format(1. / strike) + " " + pair.getSecond() + "/" + pair.getFirst();
   }
   throw new OpenGammaRuntimeException("Currencies were equal");
 }
 public static Collection<Pair<ValueSpecification, Object>> getValues(
     final ViewComputationCache cache, final Collection<ValueSpecification> specifications) {
   final Collection<Pair<ValueSpecification, Object>> values =
       new ArrayList<Pair<ValueSpecification, Object>>(specifications.size());
   for (ValueSpecification specification : specifications) {
     values.add(Pair.of(specification, cache.getValue(specification)));
   }
   return values;
 }
 @Override
 public int hashCode() {
   final int prime = 31;
   int result = 1;
   result = prime * result + _ccyPair.hashCode();
   result = prime * result + _forwardPoints.hashCode();
   result = prime * result + _multicurveProvider.hashCode();
   return result;
 }
 protected synchronized InMemoryCompiledFunctionRepository getNextCompilation(
     final Pair<FunctionRepository, Instant> key) {
   final Map.Entry<Pair<FunctionRepository, Instant>, InMemoryCompiledFunctionRepository> entry =
       getCompilationCache().higherEntry(key);
   if ((entry != null) && (entry.getKey().getFirst() == key.getFirst())) {
     return entry.getValue();
   }
   return null;
 }
 @Override
 public synchronized void remove(ObjectIdentifiable objectIdentifiable) {
   ArgumentChecker.notNull(objectIdentifiable, "objectIdentifiable");
   if (!getUniqueIdScheme().equals(objectIdentifiable.getObjectId().getScheme())) {
     throw new DataNotFoundException(
         "Scheme '"
             + objectIdentifiable.getObjectId().getScheme()
             + "' not valid for '"
             + getUniqueIdScheme()
             + "'");
   }
   final int i = objectIdentifiable.getObjectId().getValue().indexOf('_');
   if (i <= 0) {
     throw new DataNotFoundException(
         "Identifier '"
             + objectIdentifiable.getObjectId().getValue()
             + "' not valid for '"
             + getUniqueIdScheme()
             + "'");
   }
   final String name = objectIdentifiable.getObjectId().getValue().substring(0, i);
   final String iso = objectIdentifiable.getObjectId().getValue().substring(i + 1);
   final Currency currency;
   try {
     currency = Currency.of(iso);
   } catch (IllegalArgumentException e) {
     throw new DataNotFoundException(
         "Identifier '"
             + objectIdentifiable.getObjectId().getValue()
             + "' not valid for '"
             + getUniqueIdScheme()
             + "'",
         e);
   }
   final Pair<Currency, String> key = Pair.of(currency, name);
   if (_sourceVersionCorrection.getVersionAsOf() != null) {
     final TreeMap<Instant, YieldCurveDefinition> value = _definitions.get(key);
     if (value == null) {
       throw new DataNotFoundException("Curve definition not found");
     }
     // Don't need to keep the old values before the one needed by "versionAsOfInstant"
     final Instant oldestNeeded = value.floorKey(_sourceVersionCorrection.getVersionAsOf());
     if (oldestNeeded != null) {
       value.headMap(oldestNeeded).clear();
     }
     // Store a null to indicate the delete
     value.put(Instant.now(), null);
   } else {
     if (_definitions.remove(key) == null) {
       throw new DataNotFoundException("Curve definition not found");
     }
   }
   changeManager()
       .entityChanged(
           ChangeType.REMOVED, objectIdentifiable.getObjectId(), null, null, Instant.now());
 }
  /**
   * Computes the fair value strike of a spot starting VarianceSwap parameterized in 'variance'
   * terms, It is quoted as an annual variance value, hence 1/T * integral(0,T) {sigmaSquared dt}
   *
   * <p>
   *
   * @param expiry Time from spot until last observation
   * @param market VarianceSwapDataBundle containing volatility surface, forward underlying, and
   *     funding curve
   * @param cutoff The cutoff
   * @return presentValue of the *remaining* variance in the swap.
   */
  protected double impliedVarianceFromSpot(
      final double expiry, final VarianceSwapDataBundle market, final DoublesPair cutoff) {
    // 1. Unpack Market data
    final double fwd = market.getForwardCurve().getForward(expiry);
    final BlackVolatilitySurface<?> volSurf = market.getVolatilitySurface();

    VarianceCalculator varCal;
    if (cutoff == null) {
      varCal = new VarianceCalculator(fwd, expiry);
    } else {
      final ExtrapolationParameters exParCal = new ExtrapolationParameters(fwd, expiry);
      final Pair<double[], double[]> pars = exParCal.getparameters(volSurf, cutoff);
      final double[] ks = pars.getFirst();
      final double[] vols = pars.getSecond();
      final double res = getResidual(fwd, expiry, ks, vols);

      varCal = new VarianceCalculator(fwd, expiry, res, ks[0]);
    }

    return varCal.getVariance(volSurf);
  }
Exemplo n.º 26
0
 /**
  * @param priority The priority of the functions
  * @param interpolatorName The volatility surface interpolator name
  * @param leftExtrapolatorName The volatility surface left extrapolator name
  * @param rightExtrapolatorName The volatility surface right extrapolator name
  * @param propertyValuesByCurrencies Values for the properties per currency: an array of strings
  *     where the <i>i<sup>th</sup></i> currency has properties:
  *     <ul>
  *       <li><i>i</i> = first currency name,
  *       <li><i>i + 1</i> = first currency curve configuration name
  *       <li><i>i + 2</i> = first currency discounting curve name
  *       <li><i>i + 3</i> = second currency name,
  *       <li><i>i + 4</i> = second currency curve configuration name
  *       <li><i>i + 5</i> = second currency discounting curve name
  *       <li><i>i + 6</i> = surface name
  *     </ul>
  */
 public FXOptionBlackDefaults(
     final String priority,
     final String interpolatorName,
     final String leftExtrapolatorName,
     final String rightExtrapolatorName,
     final String... propertyValuesByCurrencies) {
   super(ComputationTargetType.SECURITY, true);
   ArgumentChecker.notNull(priority, "priority");
   ArgumentChecker.notNull(interpolatorName, "interpolator name");
   ArgumentChecker.notNull(leftExtrapolatorName, "left extrapolator name");
   ArgumentChecker.notNull(rightExtrapolatorName, "right extrapolator name");
   ArgumentChecker.notNull(propertyValuesByCurrencies, "property values by currency");
   ArgumentChecker.isTrue(
       propertyValuesByCurrencies.length % 7 == 0,
       "Must have two currencies, one curve config and discounting curve name per currency pair and one surface name");
   _priority = PriorityClass.valueOf(priority);
   _interpolatorName = interpolatorName;
   _leftExtrapolatorName = leftExtrapolatorName;
   _rightExtrapolatorName = rightExtrapolatorName;
   _propertyValuesByFirstCurrency = new HashMap<String, Pair<String, String>>();
   _propertyValuesBySecondCurrency = new HashMap<String, Pair<String, String>>();
   _surfaceNameByCurrencyPair = new HashMap<Pair<String, String>, String>();
   for (int i = 0; i < propertyValuesByCurrencies.length; i += 7) {
     final String firstCurrency = propertyValuesByCurrencies[i];
     final Pair<String, String> firstCurrencyValues =
         Pair.of(propertyValuesByCurrencies[i + 1], propertyValuesByCurrencies[i + 2]);
     final String secondCurrency = propertyValuesByCurrencies[i + 3];
     ArgumentChecker.isFalse(
         firstCurrency.equals(secondCurrency),
         "The two currencies must not be equal; have {} and {}",
         firstCurrency,
         secondCurrency);
     final Pair<String, String> secondCurrencyValues =
         Pair.of(propertyValuesByCurrencies[i + 4], propertyValuesByCurrencies[i + 5]);
     final String surfaceName = propertyValuesByCurrencies[i + 6];
     _propertyValuesByFirstCurrency.put(firstCurrency, firstCurrencyValues);
     _propertyValuesBySecondCurrency.put(secondCurrency, secondCurrencyValues);
     _surfaceNameByCurrencyPair.put(Pair.of(firstCurrency, secondCurrency), surfaceName);
   }
 }
  @Override
  public List<UniqueId> replaceAllVersions(
      ObjectIdentifiable objectIdentifiable,
      List<YieldCurveDefinitionDocument> replacementDocuments) {
    ArgumentChecker.notNull(replacementDocuments, "replacementDocuments");
    ArgumentChecker.notNull(objectIdentifiable, "objectIdentifiable");

    final Instant now = Instant.now();

    for (YieldCurveDefinitionDocument replacementDocument : replacementDocuments) {
      ArgumentChecker.notNull(replacementDocument, "document");
      ArgumentChecker.notNull(
          replacementDocument.getYieldCurveDefinition(), "document.yieldCurveDefinition");
      final Currency currency = replacementDocument.getYieldCurveDefinition().getCurrency();
      final String name = replacementDocument.getYieldCurveDefinition().getName();
      final UniqueId id = UniqueId.of(getUniqueIdScheme(), name + "_" + currency.getCode());
      ArgumentChecker.isTrue(id.equals(objectIdentifiable), "Invalid object identifier");
    }

    YieldCurveDefinitionDocument storedDocument = get(objectIdentifiable, null);
    if (storedDocument == null) {
      throw new DataNotFoundException("Document not found: " + objectIdentifiable);
    }
    final Currency currency = storedDocument.getYieldCurveDefinition().getCurrency();
    final String name = storedDocument.getYieldCurveDefinition().getName();
    Pair<Currency, String> key = Pair.of(currency, name);

    final TreeMap<Instant, YieldCurveDefinition> value = _definitions.get(key);
    if (value == null) {
      throw new DataNotFoundException("OID '" + objectIdentifiable + "' not found");
    }
    value.clear();

    List<YieldCurveDefinitionDocument> orderedReplacementDocuments =
        MasterUtils.adjustVersionInstants(now, null, null, replacementDocuments);

    final Instant lowestVersionFrom = orderedReplacementDocuments.get(0).getVersionFromInstant();

    ArgumentChecker.notNull(
        lowestVersionFrom, "You must define version from of the first document");

    for (YieldCurveDefinitionDocument replacementDocument : orderedReplacementDocuments) {
      value.put(
          replacementDocument.getVersionFromInstant(),
          replacementDocument.getYieldCurveDefinition());
      changeManager()
          .entityChanged(ChangeType.CHANGED, replacementDocument.getObjectId(), null, null, now);
    }
    return MasterUtils.mapToUniqueIDs(orderedReplacementDocuments);
  }
  @Override
  public ObjectsPair<Collection<LiveDataSpecification>, Collection<LiveDataSpecification>>
      splitShouldFake(
          FakeSubscriptionBloombergLiveDataServer server, Collection<LiveDataSpecification> specs) {
    if (specs.isEmpty()) {
      return Pair.of(
          (Collection<LiveDataSpecification>) new ArrayList<LiveDataSpecification>(),
          (Collection<LiveDataSpecification>) new ArrayList<LiveDataSpecification>());
    }

    Set<LiveDataSpecification> fakes = new HashSet<LiveDataSpecification>();
    Set<LiveDataSpecification> underlyings = new HashSet<LiveDataSpecification>();

    for (LiveDataSpecification liveDataSpecification : specs) {
      if (shouldFake(liveDataSpecification)) {
        fakes.add(liveDataSpecification);
      } else {
        underlyings.add(liveDataSpecification);
      }
    }

    return Pair.of(
        (Collection<LiveDataSpecification>) underlyings, (Collection<LiveDataSpecification>) fakes);
  }
 @Override
 public YieldCurveDefinition getDefinition(
     final Currency currency, final String name, final VersionCorrection versionCorrection) {
   ArgumentChecker.notNull(currency, "currency");
   ArgumentChecker.notNull(name, "name");
   final TreeMap<Instant, YieldCurveDefinition> definitions =
       _definitions.get(Pair.of(currency, name));
   if (definitions == null) {
     return null;
   }
   final Map.Entry<Instant, YieldCurveDefinition> entry =
       definitions.floorEntry(versionCorrection.getVersionAsOf());
   if (entry == null) {
     return null;
   }
   return entry.getValue();
 }
Exemplo n.º 30
0
 @Override
 public ComputedValue getComputedValue(final ValueRequirement requirement) {
   final Pair<String, Object> key =
       Pair.of(
           requirement.getValueName(),
           targetSpecKey(_resolver.getTargetSpecification(requirement.getTargetReference())));
   final ComputedValue[] values = _valuesByRequirement.get(key);
   if (values != null) {
     for (final ComputedValue value : values) {
       // Shortcut to check the properties as we already know the name and target match
       if (requirement.getConstraints().isSatisfiedBy(value.getSpecification().getProperties())) {
         return value;
       }
     }
   }
   return null;
 }