Java Order.lmtPrice方法代码示例

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order AtAuction(String action, double quantity, double price) {
	//! [auction]
	Order order = new Order();
	order.action(action);
	order.tif("AUC");
	order.orderType("MTL");
	order.totalQuantity(quantity);
	order.lmtPrice(price);
	//! [auction]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order Discretionary(String action, double quantity, double price, double discretionaryAmt) {
	//! [discretionary]
	Order order = new Order();
	order.action(action);
	order.orderType("LMT");
	order.totalQuantity(quantity);
	order.lmtPrice(price);
	order.discretionaryAmt(discretionaryAmt);
	//! [discretionary]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order PeggedToStock(String action, double quantity, double delta, double stockReferencePrice, double startingPrice) {
	//! [pegged_stock]
	Order order = new Order();
	order.action(action);
	order.orderType("PEG STK");
	order.totalQuantity(quantity);
	order.delta(delta);
	order.lmtPrice(stockReferencePrice);
	order.startingPrice(startingPrice);
	//! [pegged_stock]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order RelativePeggedToPrimary(String action, double quantity, double priceCap, double offsetAmount) {
	//! [relative_pegged_primary]
	Order order = new Order();
	order.action(action);
	order.orderType("REL");
	order.totalQuantity(quantity);
	order.lmtPrice(priceCap);
	order.auxPrice(offsetAmount);
	//! [relative_pegged_primary]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order SweepToFill(String action, double quantity, double price) {
	//! [sweep_to_fill]
	Order order = new Order();
	order.action(action);
	order.orderType("LMT");
	order.totalQuantity(quantity);
	order.lmtPrice(price);
	order.sweepToFill(true);
	//! [sweep_to_fill]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order AuctionLimit(String action, double quantity, double price, int auctionStrategy) {
	//! [auction_limit]
	Order order = new Order();
	order.action(action);
	order.orderType("LMT");
	order.totalQuantity(quantity);
	order.lmtPrice(price);
	order.auctionStrategy(auctionStrategy);
	//! [auction_limit]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order Block(String action, double quantity, double price) {
	// ! [block]
	Order order = new Order();
	order.action(action);
	order.orderType("LMT");
	order.totalQuantity(quantity);//Large volumes!
	order.lmtPrice(price);
	order.blockOrder(true);
	// ! [block]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order LimitOrder(String action, double quantity, double limitPrice) {
	// ! [limitorder]
	Order order = new Order();
	order.action(action);
	order.orderType("LMT");
	order.totalQuantity(quantity);
	order.lmtPrice(limitPrice);
	// ! [limitorder]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order LimitIfTouched(String action, double quantity, double limitPrice, double triggerPrice) {
	// ! [limitiftouched]
	Order order = new Order();
	order.action(action);
	order.orderType("LIT");
	order.totalQuantity(quantity);
	order.lmtPrice(limitPrice);
	order.auxPrice(triggerPrice);
	// ! [limitiftouched]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order LimitOnClose(String action, double quantity, double limitPrice) {
	// ! [limitonclose]
	Order order = new Order();
	order.action(action);
	order.orderType("LOC");
	order.totalQuantity(quantity);
	order.lmtPrice(limitPrice);
	// ! [limitonclose]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order LimitOnOpen(String action, double quantity, double limitPrice) {
	// ! [limitonopen]
	Order order = new Order();
	order.action(action);
	order.tif("OPG");
	order.orderType("LOC");
	order.totalQuantity(quantity);
	order.lmtPrice(limitPrice);
	// ! [limitonopen]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static List<Order> BracketOrder(int parentOrderId, String action, double quantity, double limitPrice, double takeProfitLimitPrice, double stopLossPrice) {
	//This will be our main or "parent" order
	Order parent = new Order();
	parent.orderId(parentOrderId);
	parent.action(action);
	parent.orderType("LMT");
	parent.totalQuantity(quantity);
	parent.lmtPrice(limitPrice);
	//The parent and children orders will need this attribute set to false to prevent accidental executions.
       //The LAST CHILD will have it set to true.
	parent.transmit(false);
	
	Order takeProfit = new Order();
	takeProfit.orderId(parent.orderId() + 1);
	takeProfit.action(action.equals("BUY") ? "SELL" : "BUY");
	takeProfit.orderType("LMT");
	takeProfit.totalQuantity(quantity);
	takeProfit.lmtPrice(takeProfitLimitPrice);
	takeProfit.parentId(parentOrderId);
	takeProfit.transmit(false);
	
	Order stopLoss = new Order();
	stopLoss.orderId(parent.orderId() + 2);
	stopLoss.action(action.equals("BUY") ? "SELL" : "BUY");
	stopLoss.orderType("STP");
	//Stop trigger price
	stopLoss.auxPrice(stopLossPrice);
	stopLoss.totalQuantity(quantity);
	stopLoss.parentId(parentOrderId);
	//In this case, the low side order will be the last child being sent. Therefore, it needs to set this attribute to true 
       //to activate all its predecessors
	stopLoss.transmit(true);
	
	List<Order> bracketOrder = new ArrayList<Order>();
	bracketOrder.add(parent);
	bracketOrder.add(takeProfit);
	bracketOrder.add(stopLoss);
	
	return bracketOrder;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order StopLimit(String action, double quantity, double limitPrice, double stopPrice) {
	// ! [stoplimit]
	Order order = new Order();
	order.action(action);
	order.orderType("STP LMT");
	order.lmtPrice(limitPrice);
	order.auxPrice(stopPrice);
	order.totalQuantity(quantity);
	// ! [stoplimit]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order TrailingStopLimit(String action, double quantity, double trailingAmount, double trailStopPrice, double limitPrice) {
	// ! [trailingstoplimit]
	Order order = new Order();
	order.action(action);
	order.orderType("TRAIL LIMIT");
	order.lmtPrice(limitPrice);
	order.auxPrice(trailingAmount);
	order.trailStopPrice(trailStopPrice);
	order.totalQuantity(quantity);
	// ! [trailingstoplimit]
	return order;
}
 

import com.ib.client.Order; //导入方法依赖的package包/类
public static Order ComboLimitOrder(String action, double quantity, boolean nonGuaranteed, double limitPrice) {
	// ! [combolimit]
	Order order = new Order();
	order.action(action);
	order.orderType("LMT");
	order.lmtPrice(limitPrice);
	order.totalQuantity(quantity);
	if (nonGuaranteed)
	{
		List<TagValue> smartComboRoutingParams = new ArrayList<TagValue>();
		smartComboRoutingParams.add(new TagValue("NonGuaranteed", "1"));
	}
	// ! [combolimit]
	return order;
}