I have noticed two buy orders in a row as well.

Sometimes the entire amount you enter for the order is not able to be purchased within the same minute you create the buy. The balance will be purchased on subsequent minutes.

If you have an idea of the value of your portfolio, you can do the math to see if the two consecutive buys would cover your initial buy request.

One problem I see with your function determining how many shares to buy is that it rounds. That means that if you can buy 55.7 shares, your program will buy 56 shares even though it doesn't have the capital. Also, I'm not sure if this applies here, but you want to make sure you aren't dividing two integers, because that doesn't behave normally. Try it out: round(55/7) returns 7.0 While round(float(55)/7) returns 8.0 since we are dividing a float and an int. Again, not sure if this applies here, but I think it's good to know if you are using round.

As for orders happening twice, I think Chuck is right. One way to get started dealing with this problem is to count the amount of shares in-queue. You can do this with:

tot = 0  
for o in get_open_orders(sid=sid):  
    tot += o.amount  

And the tot variable should contain the amount of open orders you have. Does that help?

Hi John,

Interesting algo, thanks for sharing. I copied your code into an algo, make a couple modifications, and then shared it below. A few thoughts:

• There's nothing in your algo that explicitly says that a "cover" has to come before a "buy." When the relationship between short and long swaps, then both the long and the short aspects of your algorithm are activated. The code runs through the sections in order, and "buy" is before "cover" so it executes in that order. You'd have to change your variables to unify the long and short aspects, or you might use an if/elif construction so it can only do one type or the other.
  
• I suspect your attempts to compute -round(context.portfolio.cash/price,0) were failing because at the time you computed them, I suspect your cash was very close to zero.

There are a bunch of different ways to tackle it, but to get the behavior you want, you have to explicitly change the code so that you can only go long or short if the previous position is already closed, and also only calculate the size of your "next" order when the old one is closed.

Thanks for all your responses here. Greatly appreciated. The real trouble I am having here is that I can't figure out another way to get short the entire account value, like I figured out with the long side--since the flip happens at one point in time. The back to back buy or sell orders doesn't bother me too much since they are both taking place at exactly the same time--thus meaning that my risk is zero and my use of borrowing would last a fraction of a second.

The cool thing I like about this algo is its simplicity. People like to get caught up thinking that their algo should be complex and use outlandish mathematical models-- in my mind simple is better. If you backtest this algo i provided starting on jan 1, 2002 (or whatever the first day of data available is) you will be quite surprised.

Anyways, I appreciate your guys' feedback, I'm prob just gonna be learning more python so I can fully understand more of how this site works and really use some of the unique features Quantopian has to offer. Have a good evening!

John

Before I forget...I feel like the rounding problem could be fixed by changing bull_shares to :

 bull_shares = (round(context.portfolio.cash/price,0)-1)

John, if I understand what you're looking for, Dennis has written some code that gets close to what you're looking for:

# calculate capital_used using absolute amount: abs(amount)*cost_basis  
pos = context.portfolio.positions  
abs_capital_used = sum(abs(pos[s].amount) * pos[s].cost_basis for s in pos)  
record(abs_capital_used = abs_capital_used)  
# calculate free cash: starting_cash + pnl - capital_used  
port = context.portfolio  
abs_cash = port.starting_cash + port.pnl - abs_capital_used  
record(abs_cash = abs_cash)  

@John and @Dan, the code fragment for abs_capital_used and abs_cash is useful if you want to know how much capital is used and/or free. Then you know how big of a position you can take to make use of all your remaining capital.

But it's not suitable if you are planning to reverse, rebalance or otherwise replace your existing positions. That is actually much easier.

# total account value at present (including active positions)  
total_capital = context.portfolio.starting_cash + context.portfolio.pnl  
# portion of account value to use for each *new* position (assuming old positions are being closed)  
position_size = total_capital / num_positions  
# number of shares to buy (short) for *this* position  
num_shares = position_size / data[stock].price  
# lets make this a short position (negative quantity)  
num_shares *= -1  
# adjust existing position to match num_shares (even works for shorts and reversals)  
order(stock, num_shares - context.portfolio.positions[stock].amount)