Add double auction trait #5
Conversation
|
@bherd-rb @rafabap I have pushed a new interface for an immutable auction on which I would like some feedback. Whether or not auctions are immutable is a fairly significant design decision. My current justification for making auctions immutable is that this leaves the handling of concurrency issues in the hands of the user. @bherd-rb I would like to make this the subject of our talk on Thursday. @rafabap you are welcome to join if interested. |
|
@davidrpugh I have a strange problem when trying to access the double auction from within Java. This is my code: public class App {
public static void main( String[] args ) {
// note: that's the only way I can call the function. I haven't figured out how to pass a type parameter.
DoubleAuction<Service> auction = DoubleAuction$.MODULE$.withEmptyOrderBook();
}
}When I compile and run the example, this is the output: I first thought it has to do with the missing type parameter in the call to object DoubleAuction {
def withEmptyOrderBook[T <: Tradable](t : T): DoubleAuction[T] = {
new DoubleAuction(FourHeapOrderBook.empty[T])
}
}I then modified my Java code as follows: public class App {
public static void main( String[] args ) {
DoubleAuction<Service> auction = DoubleAuction$.MODULE$.withEmptyOrderBook(new Service());
}
}No difference. Still the same error. Do you have any ideas?! |
|
@bherd-rb What version of Scala are you using? Is it different than 2.12.1 that I am using? |
|
Have you had trouble creating an empty def empty[T <: Tradable](implicit askOrdering: Ordering[LimitAskOrder[T]], bidOrdering: Ordering[LimitBidOrder[T]]): FourHeapOrderBook[T] = {
val matchedOrders = MatchedOrders.empty(askOrdering.reverse, bidOrdering.reverse)
val unMatchedOrders = UnMatchedOrders.empty(askOrdering, bidOrdering)
new FourHeapOrderBook(matchedOrders, unMatchedOrders)
}Note the implicit parameters. The scala compiler with automatically detect that the required orderings are defining in the companion objects of |
|
@davidrpugh I'm using 2.11.6. Yes, I think you might be right. It worked before. I'll see if I can find a solution or, at least, narrow down the problem. |
|
@bherd-rb See if this new commit fixes the problem. I had left out the implicit parameters from the |
|
@davidrpugh Ok thanks, will give it a try. When I wrap the creation of the auction into a separate Scala object that just returns an object of |
|
@davidrpugh Still the same problem. I create the auction from Java as follows: DoubleAuction<Service> auction = DoubleAuction.withEmptyOrderBook(
SinglePricePoint$.MODULE$.<LimitAskOrder<Service>>ordering(),
SinglePricePoint$.MODULE$.<LimitBidOrder<Service>>ordering().reverse());This is the result: Interestingly, I get the same error if I wrap the creation. This is the Scala creation class: class AuctionCreator[T <: Tradable] {
val createAuction = DoubleAuction.withEmptyOrderBook[T](SinglePricePoint.ordering, SinglePricePoint.ordering.reverse)
}For convenience, I created a Java equivalent: public class JAuctionCreator<T extends Tradable> {
public DoubleAuction<T> createAuction() {
return new AuctionCreator<T>().createAuction();
}
}Same error: |
|
@bherd-rb Can you show me the Java code that you used to successfully create an empty four-heap order book? |
|
@davidrpugh In the very first version, I created a simple Scala auction class as follows: class SimpleAuction {
var orderBook = FourHeapOrderBook.empty[LimitAskOrder with SingleUnit, LimitBidOrder with SingleUnit]
def + (order: LimitAskOrder with SingleUnit) = {
orderBook += order
}
def + (order: LimitBidOrder with SingleUnit) = {
orderBook += order
}
def - (order: LimitAskOrder with SingleUnit) = {
orderBook -= order
}
def - (order: LimitBidOrder with SingleUnit) = {
orderBook -= order
}
def clear() = {
val (pairedOrders, orderBook_new) = orderBook.takeWhileMatched
orderBook = orderBook_new
pairedOrders.toList
}
}I then created a Java wrapper for that class as follows: public class JSimpleAuction {
private SimpleAuction auction = new SimpleAuction();
public JSimpleAuction() {}
public void plus(LimitAskOrder order) {
auction.$plus(order);
}
public void plus(LimitBidOrder order) {
auction.$plus(order);
}
public void minus(LimitAskOrder order) {
auction.$minus(order);
}
public void minus(LimitBidOrder order) {
auction.$minus(order);
}
public java.util.List<Tuple2<LimitAskOrder, LimitBidOrder>> clear() {
List<Tuple2<LimitAskOrder, LimitBidOrder>> matchedOrders = auction.clear();
return JavaConverters.seqAsJavaListConverter(matchedOrders).asJava();
}
}That worked without any problems. I embedded an auction object into a JADE auctioneer and used it to match service providers and consumers continuously. |
|
@bherd-rb Looks like that was an older order book implementation. var orderBook = FourHeapOrderBook.empty[LimitAskOrder with SingleUnit, LimitBidOrder with SingleUnit]It is no longer necessary to pass the type parameters of the orders when creating the empty order book. Have you been able to create an empty order book using the new syntax? Copied the following from the worksheet... // Create a four-heap order book and add some orders...
val orderBook = FourHeapOrderBook.empty[Google]
val orderBook2 = orderBook + order3
val orderBook3 = orderBook2 + order4
val orderBook4 = orderBook3 + order9
val orderBook5 = orderBook4 + order8Also check your import statements. There is a |
|
@davidrpugh I know, that was a very old implementation. In my more recent wrapper (shown above), I'm using the new syntax for the order book. I have now tried to instantiate just an empty order book (without an enclosing auction) from Java: FourHeapOrderBook<Service> orderBook = FourHeapOrderBook$.MODULE$.empty(
SinglePricePoint$.MODULE$.<LimitAskOrder<Service>>ordering(), // this is line 25
SinglePricePoint$.MODULE$.<LimitBidOrder<Service>>ordering().reverse()
);Is the call correct in principle? If I execute that, it gives the same error as before (I have marked line 25 where the exception is thrown in the listing above): |
|
@bherd-rb Let's try and eliminate the versioning issue. Can you bump your version of Scala to 2.12.1? |
|
Also, can you push a branch containing your Java code? I am limited in the help that I can provide without having code that I can play with. |
|
@davidrpugh That's what I'm looking into at the moment. I'm not sure if I can switch to a more recent version because updating packages on the Linux VM that I'm working on is restricted by the company. I'll try to upgrade. If it doesn't work, I'll try from home tonight and see if it makes a difference. And yes -- I'll push the stuff to a separate branch. |
|
@davidrpugh Sorry for the radio silence, I'm drowning in work here at the moment. I tried to narrow down the problem and executed the test code on my Machine at home with the latest version of the Scala compiler – same effect! This is the simplest possible code to reproduce the problem: import org.economicsl.auctions.singleunit.*;
import org.economicsl.auctions.singleunit.orderbooks.FourHeapOrderBook;
import org.economicsl.auctions.singleunit.orderbooks.FourHeapOrderBook$
class App{
public static void main( String[] args )
{
AuctionTest auctionTest = new AuctionTest();
FourHeapOrderBook<Service> orderBook = FourHeapOrderBook$.MODULE$.empty(
LimitAskOrder$.MODULE$.<LimitAskOrder<Service>>ordering()
LimitBidOrder$.MODULE$.<LimitBidOrder<Service>>ordering()
}
}When executing that code, it crashes with the error shown further above. |
|
For sake of clarity can you show the exact error for this simplified case? I am very unfamiliar with Java syntax but these lines look strange to me... LimitAskOrder$.MODULE$.<LimitAskOrder<Service>>ordering()
LimitBidOrder$.MODULE$.<LimitBidOrder<Service>>ordering()...can the compiler infer the type parameter in this case? This would lead to something like... LimitAskOrder$.MODULE$.ordering()
LimitBidOrder$.MODULE$.ordering()...or maybe even passing the type parameter as ... LimitAskOrder$.MODULE$.ordering<LimitAskOrder<Service>>()
LimitBidOrder$.MODULE$.ordering<LimitBidOrder<Service>>()...then again the error is a run-time error and not a compile error. So this is probably off base. |
|
@davidrpugh The first option is automatically provided by IntelliJ's code completion. The second option also compiles, but produces the same error at runtime. The third option doesn't compile. Here is again the error: I'll keep investigating. |
|
@bherd-rb How are you compiling the Scala code? |
|
@bherd-rb When I compile the scala code locally I use SBT as follows... sbt compile...from with the On my laptop it seems like IDEA is sometimes (but not always!!) caching such compiler options. I think the following will compile and clean the cache. sbt clean compileIf you want to double confirm that the compiler is using the new options try running... sbt clean debug compile...and search through the cruft that is kicked out for a few lines that look like... [debug] Calling Scala compiler with arguments (CompilerInterface):
[debug] -feature
[debug] -language:implicitConversions |
|
@bherd-rb I think that the above might solve the problem because, from the run-time error, it seems like a method that should exist on an object in the core Scala library does not exist. I think this method is dynamically created at compile time when either |
|
@bherd-rb can you push your Java code to a separate branch? I would like to be able to replicate this issue on my local machine. |
|
@davidrpugh I think I solved the problem. But I still have some minor issues. I'll push the stuff and describe what I've done once everything's working correctly. |
Added simple Java wrapper for double auction plus test classes
…cSL/auctions into add-java-auction-wrapper
Add java auction wrapper
…ws for discriminatory pricing.
|
@bherd-rb I did a significant refactor of the Instances are created as follows... val uniformAuction = DoubleAuction.withUniformPricing[Google]
val discriminatoryAuction = DoubleAuction.withDiscriminatoryPricing[Google]I made some minor edits to the Java code to fix some minor compilation issues, but have not added code to use the new discriminatory price auction. Let me know what you think! |
|
@davidrpugh Looks good! I will change the Java class accordingly. |
@bherd I have added a quick sketch of the interface for a
DoubleAuction. Up until now everything has been immutable, however at this point I think it is time to think about encapsulating mutable state. In particular I am thinking about have the auction store a mutable reference to its immutable order book.