# Paweł Szwajcar Rafał Zaorski. Czego nie zrobi się dla pieniędzy?

Starcie tytanów czy biznes

Forex to magiczne miejsce gdzie niczym w polityce wszystko jest możliwe, a schodząc na pozom biznesowy gdzie "nigdy nie mówi się nigdy". Historia z życia wzięta. Oni dwaj, a każdy chce być większy od drugiego. 

Paweł Szwajcar

Paweł Szwajcar zaczął budować swój "autorytet" jeszcze w czasach świetności forum na "Nawigatorze". Lansował "piramidowanie" i zwalczał "grid". O co chodzi? O agresywne podnoszenie stawki zakładu. W pierwszym przypadku po wygranej w drugim po przegranej. Wystarczy udać się do kasyna i sprawdzić, że niezależnie od użytego "systemu" stawkowania zostaniecie bankrutem.

Paweł Szwajcar do dziś nie rozwiązał problemu gdzie leży granica między "piramidowaniem", a "gridem" uważając, że dwie pozycje na stracie na jednym instrumencie to jeszcze nie grid. A jaka jest różnica pomiędzy posiadaniem 10 stratnych pozycji na jednym instrumencie, a posiadaniem 10 stratnych pozycji na 5 instrumentach? W obu przypadkach rachunek jest w "gridzie".

Czy Paweł Szwajcar zarobił jakieś pieniądze na "piramidowaniu" to nie wiem, ale chyba nie za duże bo zaczął szukać nowych pomysłów na wzbogacenie np. "overbalance". "Przegapił" moment wejścia w media społecznościowe i został w tyle za robiącym medialną "karierę" Rafałem Zaorskim. Powrócił "do gry" projektem pod nazwą "Grupa Traderów" zaprzęgając do promocji media społecznościowe. Dalej pozostaje przekuć ruch na pieniądze poprzez np. sprzedaż szkoleń czy dostępu do "Platformy Edukacyjnej Grupy Traderów":
Paweł Szwajcar zarządzanie cudzym kapitałem. Ile można zarobić na platformie edukacyjnej?

Rafał Zaorski

Rafał Zaorski pojawił się na forexie "znikąd". Chwalił się 20 letnim stażem, ale "starzy" go nie kojarzyli. W pierwszych latach warszawskiej giełdy gdy "nie było jeszcze niczego" ludzie spotykali się w biurach maklerskich i wszyscy "wielcy" w mieście się znali.

Pomysł na zarabianie na forexie zaczerpnął ze znanej sobie branży elearningowej (model performance fee). Pomysł był "nowatorski" w stosunku do tego co robili "klasyczni" szkoleniowcy. Połączył na platformie YouTube nieodpłatne udostępnianie "szkoleń" ze sprzedażą widocznych w tle reklam. Reszta to wyszukiwanie chwytliwych tematów i przyciąganie jak największej liczby "subskrybentów". Tu inspiracją mógł być ówczesny "król" forexowych szkoleń z YouTuba Sebastian Urbański. Aktualnie jego najstarszy klip liczy 10 lat, a podpis pod nim głosi: "Zobacz jak zarabiają na giełdzie FOREX profesjonaliści. Ponad 15 lat doświadczenia zobowiązuje! 1500% w ciężkich warunkach Macro". Jak czytacie narracja od lat jest niezmienna i ... ciągle działa.

Kolejnym dobrym krokiem było równoległe rozwijanie grupy na Facebooku. Po uzyskaniu statusu "celebryty" i "króla polskich spekulantów" nadszedł słabszy okres. Kolejne projekty straciły na "świeżości", a spory sądowe nie zatrzymały konkurencji. 

Zaproszenie do konkursu Trading Skill VI

 

Paweł Szwajcar zaprosił do zorganizowanego przez siebie konkursu "Trading Skill VI" Rafała Zaorskiego. Decyzja "podejrzenia" bo Panowie za sobą nie przepadają: 

Paweł Szwajcar odszczeka kłamstwa w sądzie, Rafał Zaorski pozywa. Kiedy rozprawa?

Paweł Szwajcar lubi stosować nieskomplikowaną strategię marketingową: "bij mistrza". To zawsze nieźle się sprzedaje wśród mało wymagającego odbiorcy niczym telenowela czy kolorowa prasa. W przypadku porażki wystarczy przeprosić, to nic nie kosztuje, a "reklama" bezcenna.

Przyjęcie zaproszenia. Czy to wypada?

Rafał Zaorski przyjął zaproszenie. Decyzja "kontrowersyjna" w świetle wypisanego na TJS hasła: "...sprzedajesz twarz i tyłek XTB opuść naszą grupę ...". 

TJS - sprzedajesz tyłek i twarz XTB opuść naszą grupę

Co skłoniło Rafała Zaorskiego do "wspierania" swoim nazwiskiem projektu Pawła Szwajcara, który udzielał się w XTB? Może to, że sam reklamował XTB i grał na prowadzonym u brokera rachunku?

Paweł Szwajcar, Moje metody handlu - XTB Trading Club

XTB Trading Club - szkolenie poprowadzi Paweł Szwajcar FX. 

Przedstawienie w skrócie metod handlu: Overbalance, ATR, SMA33, Envelopes, Piramidowanie zysków. Wyjaśnienie co to takiego GRID strat i dlaczego trzeba na niego uważać. Zastosowanie każdej metody w praktyce na aktualnym rynku wraz z podaniem kilku ostatnich setupów i przykładów transakcji.

To nie pierwszy przypadek rozdźwięku pomiędzy tym co się mówi, a tym co się robi. "Traderzy mieli zarabiać na rynku", ale "największy" z nich zarabiał na sprzedaży "banerów na grupie".

Co skłoniło Rafała Zaorskiego do "wspierania" swoim nazwiskiem Pawła Szwajcara pokazującego się  w towarzystwie Patryka Krupińskiego, którego firmę "Exp Asset" TJS posądził o zorganizowanie piramidy finansowej? Może to, że w ramach TJS Patryk Krupiński prowadził "szkolenie" z opcji, a krytyczny wobec Exp Asset klip "Zaorski przychodzi do EXP ASSET która twierdzi że nie jest piramidą finansową" zniknął z kanału TJS na YT (Vimeo, czeska wersja)? Firma upadła, a pieniądze uczestników ... . Negatywny bohater przesiadł się do sportów samochodowych: Exp Racing, obecnie spółka w likwidacji.

Patryk Krupiński, TJS - Zalety opcji

Gościem Specjalnym #26 Trading Jam Session był Patryk Krupiński, zawodowy trader z wieloletnim doświadczeniem. Opowiedział nam o możliwości obniżenia ryzyka inwestycyjnego dzięki instrumentowi, jakim są opcje. Zapraszamy do oglądania.

"Wieloletnim" ... przypomnę - rocznik 1988, ale może w tej branży lata liczą się podwójnie a nawet poczwórnie. Jeden z komentarzy:

czy Patryk zna jakies opcje zabezpieczajace przed piramidami finansowymi?

Phil Konieczny nowe wypiera stare

Mam nadzieję, że Paweł Szwajcar i Rafał Zaorski pokażą jeszcze coś nowego. Na razie "stare dinozaury" muszą uznać wyższość młodego pokolenia youtuberów.

Dla porównania Phil Konieczny kryptowalutowa "mega gwiazda" YouTuba ma od lipca 2017 roku ponad 142.000 subskrypcji i ponad 11 milionów wyświetleń. TJS od lutego 2016 roku ponad 36.000 subskrypcji i ponad 4,5 miliona wyświetleń. Sebastian Urbański od maja 2010 roku ponad 6 tysięcy subskrypcji i ponad 860 tysięcy wyświetleń. Grupa Traderów od lutego 2019 roku około 6 tysięcy subskrypcji i niecałe 400 tysięcy wyświetleń. Wyniki "sprzedażowe" mówią same za siebie.

# Nic takiego lub czwarty rok istnienia forum a zysków z forexu ani widu ani słychu

Szeptunka zwana też szeptuchą

W światku forexowym po staremu. Dwa komercyjne fora ... i ... tyle ... tylko jakby szkoły forex przycichły, a może mi się zdaje.

Ostatnim hitem na pokonanie rynku miało stać się piramidowanie albo jak kto woli gridowanie. Niestety konkurs o to kto więcej na tym zarobi przekształcił się w konkurs na największego forexowego blondyna roku. Właśnie, może wprowadzę taki konkurs ... nagrodą będzie sława.

W sumie co tam. Całe to gadanie ludzi nie obchodzi. Ludzie chcą wiedzieć gdzie jutro mają postawić zlecenie i gdzie ustawić TP i tyle. Nie chcą tracić czasu na czytanie jakiś "pierdół". SL? A po co? Przecież zlecenie będzie zyskowne to chyba oczywista oczywistość.

Wskaźnik forex

Nawet mam taki wskaźnik. Przeróbka z czegoś innego. Żadna "choinka". Dwie cyfry do przepisania do zlecenia po obudzeniu i koniec. 

Niestety, ludzie nic nie mogą znaleźć. Choćby sposobu jak za pomocą forexu pokonać lokatę bankową, a to powinni dokładać gratis. To może ja podpowiem. W 2014 wystarczyło mieć forexowy rachunek w dolarach hamerykańskich i nic nie robić.

Rok 2014 to był rok dolara. "Jazdy" były takie na parach walutowych, że wszyscy "trenderzy" powinni być już grubymi milionerami. 

# Cytują nas na Nawigatorze czyli jak się kradnie na forexie nie tylko pieniądze

Autorytet

Niemożliwe, a jednak prawdziwe. Nasze forum autorytetem dla komercyjnego Nawigatora. Użytkownik "inspir" założył temat: "PIRAMIDA prosty system, a czy może być efektywny??". Do bezproblemowego znalezienia na "Nawi".

Opisuje tam system, którego opis skopiował z naszego forum. Niestety nie podał źródła.

opisze co i jak.....może jakieś EA zrobi ktoś..

Do porównania:

Piramida użyta w forex konkursie BOSSY

Dla przypomnienia

"Piramidowanie" w ostatnich miesiącach to taka ostatnia "brzytwa do chwycenia" na komercyjnych polskich forach forexowych mająca być sposobem na pokonanie brokera. Chyba największym propagatorem tego stylu gry na forexie jest kolega "Szwajcar". Robi to od kilku lat i ma teraz swoje 5 minut. Zabierał głos również na tym forum.

System gry dobrze znany z kasyn polegający na powiększaniu stawki po przegranej. W klasycznej formie podwajanie stawki, ale można użyć dowolnego mnożnika. Krótko mówiąc chodzi o martyngał polegający na zwiększaniu stawki zakładu (zwiększanie zaangażowanego kapitału). Można to robić po przegranej lub po wygranej pozycji. Nazwa "piramidowanie" odnosi się do martyngału polegającego na podnoszeniu stawki po wygranej.

Grając w ten sposób w kasynie dostatecznie długo zawsze przegracie co wynika z przewagi kasyna w postaci "zera". Manipulowanie stawką zakładu nie prowadzi w żaden sposób do zmniejszenia statystycznej przewagi organizatora gry [1]. W odniesieniu do detalicznego forexu czyli zakładów finansowych odpowiednikiem "zera" jest spread i inne koszty. Manipulowanie stawką zakładu ma wtedy sens kiedy posiadacie przewagę nad organizatorem. Kiedy brak przewagi jest to narzędzie przyspieszające ponoszenie strat i prowadzące w ostateczności do wyzerowania rachunku.

Nie rozwodząc się dalej - na razie koledze Szwajcarowi nie udało się w weryfikowalny sposób pokazać, że to działa w dłuższym terminie.

Do zanalizowania

Pod linkiem niżej jest przykład strategii, która zawiera w sobie zarówno "grid" jak i "piramidę". Niezależnie od kierunku ruchu rynku kiedy w jedną stronę grany jest "grid" automatycznie w drugą stronę grana jest "piramida" i odwrotnie. Jeżeli na forexie można zarobić to ta strategia powinna być na plusie, a jednak po 60 tygodniach trwania nie jest.

Hedging na forexie czyli matematyka na usługach albo sens w bezsensie

Nie musicie mi wierzyć. Tą strategią możecie pobawić się na demo i sami sprawdzić. Model jest opisany, a parametry ustawiacie jakie chcecie (skuteczna metoda to taka, która nie jest zależna od optymalizowania parametrów na danych historycznych). Oczywiście ustawianie zleceń "gęściej" niż wartość kosztów (spread i inne) nie ma sensu. Ta strategia wyciska z rynku każdego pipsa z zadaną rozstawem zleceń dokładnością przy tym nie wymaga znajomości żadnej analizy. Po prostu więcej nie da się zarobić na forexie.
--------------------------------------------------
[1] Zmiana stawki zakładu nie skutkuje zmianą prawdopodobieństwa. Jedną z motywacji powstania teorii martyngału było pokazanie niemożliwości istnienia wygrywających strategii w grach hazardowych.

# Robot do stawiania siatki zleceń można użyć do stawiania piramid

Automat do stawiania siatki zleceń

Instrukcja oraz kod robota (EA) o nazwie "MakeGrid193" do stawiania siatki zleceń [1].

Instrukcja

Following on numerous mails, I would like to point out that this is NOT a trading system and a straight implementation of MakeGrid on any currency pair is bound to blow your account - sooner or later - unless you are very rich and patient.

Risk

As a simple exercise, try calculating the drawdown on your account for 1k lots on a 6 pip grid over a range of 3000 pips (this is typical of an annual move).
It comes out to something like 60'000 $ depending on the pair you trade. That is a lot of money for something like 300 pips a day.

Other than that, I found it to be a super tool to learn the different ways of trading grids and the variants that people in the boards were mentioning and trying.

After back and forward testing it with a lot of variants, I really changed my way of looking at grids. It is a really strange beast to trade.

Before trying this with real money, please do your maths. Your account chould be able to handle a 3000 pip drop in a few days without being near a margin call. Personally, I use 50 pip grids and count 4 - 6000 $ of Equity per currency traded per 1000 lot size. Also, watch out for rollover interest / charges as, depending on the broker, this can really mess you up. Having lots of GBP/JPY short positions is not a good idea!

What the EA does

The basic program does the following: Every few minutes ( determined by UpdateInterval ), it will calculate the first entry price at current price minus gridsize * gridsteps / 2.

ex. if we are at 1.2000, gridsize is 50, gridsteps is 12, 50 x 12 /2 = 300.
The first order would be placed at 1.2000 - .0300 = 1.1700 and the last order at 1.2300. This gives 12 orders at 50 pip intervals. Note that orders are placed at round numbers : 100, 150, 200 etc for a 50 pip grid, 10, 20, 30, 40 etc for a 10 pip grid.

Before placing orders, the EA looks to see if we either have a position or an existing order near the relevant price. By 'near' I mean within 9/10th of the grid size. i.e. for a 50 pip grid, the EA will look to see if we have an existing order or position 45pips above or 45 pips below the required price.
This looks a bit extreme but is a simple way to reduce the risk of duplicate positions.

If an order / position does not exist at the slot, it will create one (stop or limit) with the TP and SL as specified. TP is necessary, SL is optional.

There are many flage to determine whether the order should be placed. They are discussed below.

Once it has placed orders, it can do some housekeeping. For example, it can delete orders that are too far out ( in out example, orders that are more than 300pips away from the current price) so as to limit the server load. It can also delete orders after a specified number or hours.

Parameters

There are lots of different flags that allow you to test variants :

Lots - the lot size you want to trade.
GridSize - the interval between orders, in pips
GridSteps - the number of open orders the EA will try to set above and below the current price
TakeProfit - the TP in pips
StopLoss - If you want a stoploss, specify in pips. 0 means no stoploss.
wantLongs - if you want longs to be opened. ex. eur/huf, you may not want longs
wantShorts - if u want short positions opened.
- if both are true, both longs and shorts will be opened

Some people wanted to open positions only if 'with the trend' (i.e. for longs, above the current price ) and others only against the trend (i.e. if longs, only below the current price).

wantBreakout - sets orders above the price for longs and below the current price for shorts
wantCounter - sets long orders below the current price, shorts above current price.

GridMaxOpen - will make sure that no more than this number of positions is open at any one time. This is a way of limiting drawdown risk.

minFromPrice - this is the minumum distance, in pips, from the current price, that one can place a trade. For example, we only want a breakout of at least 30 pips from the current price. This can be used in conjunction with wantBreakout and wantCounter.

All the above parameters will work on ANY time frame chart and give exactly the same results. The parameters below are time frame dependent. I have mostly used them on 5 min charts but lots of people have tried on longer time frames.

It is possible to limit long orders only if they are above an EMA and shorts below. The EMA period is set by the EMAPeriod flag and the flag is limitEMA. If true, it will test this condition. The housekeeping routine will remove orders that end up on the wrong side of the EMA.

UseMACD and useOSMA are similar. If true, only longs will be placed if the MACD (OsMA) signal is above zero. All short orders will be cancelled.
The opposite is true for MACD below zero. All the MACD parameters are specifiable (fast and slow ema, signal period), including the chart time frame (timeFrame).
When either of these signals is true, it is possible to have the EA close open positions (whether gain or loss) that are on the wrong side. i.e. if MACD crosses up, all short orders are cancelled but if CloseOpenPositions is true, all short open positions are closed. The new grid is setup as a long grid.

These flage work in conjunction with wantLongs and wantShorts.
Hence it is possible to setup a grid of longs only, above the 34 EMA, above the current price plus 20 pips (minFromPrice) and only if MACD is positive.

With a bit of simple programming, you can change either of these to use your favourite index.

Future direction

I regularly add in suggestions other traders have found useful. I have not read this whole thread so if someone can summarise the variants that are needed, I may try to program them in.

However, as a good contribution to the advancement of grid trading, if someone has an effective way of limiting drawdown, I will be very happy to hear it.

Other than MACD and OsMA, I have not found that the other methods are useful in improving the system. These can limit the drawdown by up to about 50%.

In particular, I have found that any stoploss, time limit or CloseOpenPositions lead to losing strategies.

For real trading, the main direction I have moved in is trading a group of selected currency pairs. This is impossible to backtest properly on MetaTrader so I have an API as well as some custom programs and tons of tick data.

Conclusion

I hope this short tutorial on MakeGrid helps better understand how it works and the risks inherant in grid trading. If we can come up with ways to reduce drawdown, then we can have a good simple automated trading system that would be accessible to the normal retail trader.

Dream on!

Kod robota

//+------------------------------------------------------------------+
//|                                                  MakeGrid193.mq4 |
//|                                            Copyright © 2005, hdb |
//|                                       http://www.dubois1.net/hdb |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, hdb"
#property link      "http://www.dubois1.net/hdb"
//#property version      "1.93"
// DISCLAIMER ***** IMPORTANT NOTE ***** READ BEFORE USING *****
// This expert advisor can open and close real positions and hence do real trades and lose real money.
// This is not a 'trading system' but a simple robot that places trades according to fixed rules.
// The author has no pretentions as to the profitability of this system and does not suggest the use
// of this EA other than for testing purposes in demo accounts.
// Use of this system is free - but u may not resell it - and is without any garantee as to its
// suitability for any purpose.
// By using this program you implicitly acknowledge that you understand what it does and agree that
// the author bears no responsibility for any losses.
// Before using, please also check with your broker that his systems are adapted for the frequest trades
// associated with this expert.
// 1.8 changes
// made wantLongs and wantShorts into local variables. Previously, if u set UseMACD to true,
//       it did longs and shorts and simply ignored the wantLongs and wantShorts flags.
//       Now, these flags are not ignored.
// added a loop to check if there are 'illicit' open orders above or below the EMA when the limitEMA34
//       flag is used. These accumulate over time and are never removed and is due to the EMA moving.
// removed the switch instruction as they dont seem to work - replaced with if statements
// made the EMA period variable
//
// 1.9 changes - as per kind suggestions of Gideon
// Added a routine to delete orders and positions if they are older than keepOpenTimeLimit hours.
// Added OsMA as a possible filter. Acts exactly like MACD.
// Added 4 parameters for MACD or OsMA so that we can optimise
// Also cleaned up the code a bit.
// 1.92 changes by dave
// added function openPOsitions to count the number of open positions
// modified the order logic so that openPOsitions is not > GridMaxOpen
// 1.93 added long term direction indicator
// Added tradeForMinutes  - will only trade for this time then stop till EA is reset.
//
// modified by cori. Using OrderMagicNumber to identify the trades of the grid
extern int    uniqueGridMagic = 9999; // Magic number of the trades. must be unique to identify
                                       // the trades of one grid   
extern double Lots = 0.1;              //
extern double GridSize = 10;            // pips between orders - grid or mesh size
extern double GridSteps = 10;          // total number of orders to place
extern double TakeProfit = 10;         // number of ticks to take profit. normally is = grid size but u can override
extern double StopLoss = 0;            // if u want to add a stop loss. normal grids dont use stop losses
extern int    trailStop = 0;           // will trail if > 0
extern double UpdateInterval = 0.1;    // update orders every x minutes
extern bool   wantLongs = true;       // do we want long positions
extern bool   wantShorts = true;       // do we want short positions
extern bool   wantBreakout = true;    // do we want longs above price, shorts below price
extern bool   wantCounter = true;      // do we want longs below price, shorts above price
extern bool   limitEMA = false;        // do we want longs above ema only, shorts below ema only
extern int    EMAperiod = 34;          // the length of the EMA.. was previously fixed at 34
extern double GridMaxOpen = 0;         // maximum number of open positions : implemented in v1.92
extern bool   UseMACD = false;         // if true, will use macd >0 for longs only, macd <0 for shorts only
                                       // on crossover, will cancel all pending orders. Works in conjunction with wantLongs and wantShorts.
extern bool   UseOsMA = false;         // if true, will use OSMA > 0 for longs only, OSMA <0 for shorts only. used in same way as MACD.
                                       // If both UseMACD and UseOSMA atr true, OSMA is taken.
extern bool CloseOpenPositions = false;// if UseMACD, do we also close open positions with a loss?
extern bool   doHouseKeeping = true;   // this will remove long orders below the 34 ema and vv if limitEMA flag is true
extern double keepOpenTimeLimit = 0;   // in hours - if > 0, all open orders or positions will be closed after this period. fractions are permitted
extern int    emaFast = 12;            // parameters for MACD and OSMA
extern int    emaSlow = 26;            // parameters for MACD and OSMA
extern int    signalPeriod = 9;        // parameters for MACD and OSMA
extern int    timeFrame = 0;           // parameters for MACD and OSMA
extern int    minFromPrice = 0;        // minimum distance from price to place trades.
extern int    tradeForMinutes=0;       // will trade for this number of minutes after being initialised.
                                       // add/readd the EA before news and it will trade for these minutes then close out all positions at end
extern int    gridOffset = 0;          // positions are opened at price modulo GridSize and offset with this parameter.
                                       // used essentially to enter at non round numbers
// the following flags set bounds on the prices at which orders may be placed
// this code was developed for and is kindly made public by Exc_ite2

extern double longGridCenter = 0;      // defines the center point of a fixed width long grid                                      
extern double shortGridCenter = 0;     // defines the center point of a fixed width short grid                                      

extern double longGridLow = 0;         // defines the bottom of a fixed width long grid
extern double longGridHigh = 0;        // defines the top of a fixed width long grid

extern double shortGridLow = 0;         // defines the bottom of a fixed width short grid
extern double shortGridHigh = 0;        // defines the top of a fixed width short grid

extern double profitTarget = 99999;     // if > 0, will close out all positions once the $ target has been met

extern bool   suspendGrid = false;       // if set to true, will close all unfilled Orders
extern bool   shutdownGrid = false;      // if set to true, will close all orders and positions.
                                      
// modified by cori. internal variables only
string   GridName = "Grid";              // identifies the grid. allows for several co-existing grids - old variable.. shold not use any more
double   LastUpdate = 0;                 // counter used to note time of last update
double   startTime = 0;                  // counter to note trade start time.
double   closedProfit = 0;               // counts closed p&l
double   openProfit = 0;                 // counts open p&l
double   accumulatedProfit = 0;          // for back testing only
bool     haveHitTarget = false;          //  if there is a target, this flag says we have hit it
int      openLongs = 0;                  //  how many longs are open
int      openShorts = 0;                 // how many shorts are open
bool     gridActive = true;              // is the grid active
bool     gridOneShot = false;       // is this a one shot? if so, it stops after the profitTarget has been reached

//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
 #property show_inputs                  // shows the parameters - thanks Slawa...   
//----
   GridName = StringConcatenate( "Grid-", Symbol(),"-",uniqueGridMagic );
   return(0);
  }
//+------------------------------------------------------------------------+
//| tests if there is an open position or order in the region of atRate    |
//|     will check for longs if checkLongs is true, else will check        |
//|     for shorts                                                         |
//+------------------------------------------------------------------------+

bool IsPosition(double atRate, double inRange, bool checkLongs )
  {
     int totalorders = OrdersTotal();
     for(int i=0;i<totalorders;i++)                                // scan all orders and positions...
      {
        OrderSelect(i, SELECT_BY_POS);
// modified by cori. Using OrderMagicNumber to identify the trades of the grid // hdb added or gridname for compatibility
        if ( OrderSymbol()==Symbol() && ( (OrderMagicNumber() == uniqueGridMagic) || (OrderComment() == GridName)) )  // only look if mygrid and symbol...
         {  int type = OrderType();
            if (MathAbs( OrderOpenPrice() - atRate ) < (inRange*0.9)) // dont look for exact price but price proximity (less than gridsize) - added 0.9 because of floating point errors
              { if ( ( checkLongs && ( type == OP_BUY || type == OP_BUYLIMIT  || type == OP_BUYSTOP ) )  || (!checkLongs && ( type == OP_SELL || type == OP_SELLLIMIT  || type == OP_SELLSTOP ) ) )
                 {
                    return(true);
                 }
              }
         }
      }
   return(false);
  }

//+------------------------------------------------------------------+
//| Delete order after x hours                                     |
//+------------------------------------------------------------------+
void DeleteAfter( double xHours )    // delete pending orders or open positions after x hours
  {
  int totalorders = OrdersTotal();
  for(int i=totalorders-1;i>=0;i--)
     OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
// we use iTime so it works in backtesting
     if ( OrderSymbol()==Symbol() && ( (OrderMagicNumber() == uniqueGridMagic) || (OrderComment() == GridName)) )  // only look if mygrid and symbol...
        {
            if (( MathAbs(iTime(Symbol(),5,0)-OrderOpenTime()) >= xHours*60*60 ) && (iTime(Symbol(),5,0)>0))
            {  bool result = false;
               //Close opened long position
               if ( OrderType() == OP_BUY )  result = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red );
               //Close opened short position
               if ( OrderType() == OP_SELL )  result = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Red );
               //Close pending order
               if ( OrderType() > 1 ) result = OrderDelete( OrderTicket() );
           }
        }
     
  } // proc DeleteAfter()


//+------------------------------------------------------------------------+
//| cancells all pending orders                                      |
//+------------------------------------------------------------------------+

void CloseAllPendingOrders( )
  {
     int totalorders = OrdersTotal();
     for(int i=totalorders-1;i>=0;i--)                                // scan all orders and positions...
      {
        OrderSelect(i, SELECT_BY_POS);
// modified as per cori. Using OrderMagicNumber to identify the trades of the grid // hdb added or gridname for compatibility
        if ( OrderSymbol()==Symbol() && ( (OrderMagicNumber() == uniqueGridMagic) || (OrderComment() == GridName)) )  // only look if mygrid and symbol...
         { 
          if ( OrderType() > 1 ) bool result = OrderDelete( OrderTicket() );
         }
      }
   return;
  }
//+------------------------------------------------------------------------+
//| cancells all pending orders    and closes open positions               |
//+------------------------------------------------------------------------+

void ClosePendingOrdersAndPositions()
{
  int totalorders = OrdersTotal();
  for(int i=totalorders-1;i>=0;i--)
 {
    OrderSelect(i, SELECT_BY_POS);
    bool result = false;
// modified by cori. Using OrderMagicNumber to identify the trades of the grid // hdb added or gridname for compatibility
    if ( OrderSymbol()==Symbol() && ( (OrderMagicNumber() == uniqueGridMagic) || (OrderComment() == GridName)) )  // only look if mygrid and symbol...
     {
           //Close opened long positions
           if ( OrderType() == OP_BUY )  result = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red );
           //Close opened short positions
           if ( OrderType() == OP_SELL )  result = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Red );
           //Close pending orders
           if ( OrderType() > 1 ) result = OrderDelete( OrderTicket() );
      }
  }
  return;
}

//+------------------------------------------------------------------------+
//| cancells all open orders which fall on the wrong side of the EMA                                     |
//+------------------------------------------------------------------------+

void CloseOrdersfromEMA( double theEMAValue )
  {
     int totalorders = OrdersTotal();
     for(int i=totalorders-1;i>=0;i--)                                // scan all orders and positions...
      {
        OrderSelect(i, SELECT_BY_POS);
        if ( OrderSymbol()==Symbol() && ( (OrderMagicNumber() == uniqueGridMagic) || (OrderComment() == GridName)) )  // only look if mygrid and symbol...
         { 
          int type = OrderType();
          bool result = false;
//if (type > 1) Print(type,"  ",theEMAValue,"  ",OrderOpenPrice());
          if ( type == OP_BUYLIMIT && OrderOpenPrice() <= theEMAValue ) result = OrderDelete( OrderTicket() );
          if ( type == OP_BUYSTOP && OrderOpenPrice() <= theEMAValue ) result = OrderDelete( OrderTicket() );
          if ( type == OP_SELLLIMIT && OrderOpenPrice() >= theEMAValue ) result = OrderDelete( OrderTicket() );
          if ( type == OP_SELLSTOP && OrderOpenPrice() >= theEMAValue ) result = OrderDelete( OrderTicket() );
         }
      }
   return;
  }

//+------------------------------------------------------------------------+
//| counts the number of open positions                                    |
//+------------------------------------------------------------------------+

int openPositions(  )
  {  int op =0;
     int totalorders = OrdersTotal();
     for(int i=totalorders-1;i>=0;i--)                                // scan all orders and positions...
      {
        OrderSelect(i, SELECT_BY_POS);
        if ( OrderSymbol()==Symbol() && ( (OrderMagicNumber() == uniqueGridMagic) || (OrderComment() == GridName)) )  // only look if mygrid and symbol...
         { 
          int type = OrderType();
          if ( type == OP_BUY ) {op=op+1;}
          if ( type == OP_SELL ) {op=op+1;}
         }
      }
   return(op);
  }

//+------------------------------------------------------------------+
//| Close on profit target                                           |
//+------------------------------------------------------------------+
void TestForProfit( int forMagic, double profittarget, bool testOpen, bool testHistory )                   // based on trailing stop code from MT site... but modified as per Hiro
  {
    if (profittarget > 0 )
     {
         closedProfit = 0;                // counts closed p&l

         if (testHistory == true) {
            int total = HistoryTotal();
            for(int i=0;i<total;i++)                                // scan all closed / cancelled transactions
              {
              OrderSelect(i, SELECT_BY_POS, MODE_HISTORY );
              if ( OrderSymbol() == Symbol() && OrderMagicNumber() == forMagic )  // only look if mygrid and symbol...
                {
                 closedProfit = closedProfit + OrderProfit();
               }
              }
          } else {
             accumulatedProfit =0;
          }
         
         openProfit = 0;                  // counts open p&l

         if (testOpen == true) {
            total = OrdersTotal();
            openLongs = 0;
            openShorts = 0;
            for(i=0;i<total;i++)                                // scan all open orders and positions
              {
              OrderSelect(i, SELECT_BY_POS );
              if ( OrderSymbol() == Symbol() && OrderMagicNumber() == forMagic )  // only look if mygrid and symbol...
                {
                  openProfit = openProfit + OrderProfit();
                  int type = OrderType();
                  if ( type == OP_BUY ) {openLongs=openLongs+1;}
                  if ( type == OP_SELL ) {openShorts=openShorts+1;}
                }
              }
           }
         if ( ( closedProfit + openProfit) >= (profittarget + accumulatedProfit) )
            {
               Print("Closing grid due to profit target");
               ClosePendingOrdersAndPositions();
               accumulatedProfit = accumulatedProfit + closedProfit + openProfit;
               haveHitTarget = true;
               if (gridOneShot==true) { gridActive = false; }
            }
     }
  }


//+------------------------------------------------------------------+
//| Trailing stop procedure                                          |
//+------------------------------------------------------------------+
void TrailIt( int byPips )                   // based on trailing stop code from MT site... thanks MT!
  {
  if (byPips >=5)
  {
  for (int i = 0; i < OrdersTotal(); i++) {
     OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
     if ( OrderSymbol()==Symbol() && ( (OrderMagicNumber() == uniqueGridMagic) || (OrderComment() == GridName)) )  // only look if mygrid and symbol...
        {
            if (OrderType() == OP_BUY) {
               //if (Bid > (OrderValue(cnt,VAL_OPENPRICE) + TrailingStop * Point)) {
               //   OrderClose(OrderTicket(), OrderLots(), Bid, 3, Violet);
               //   break;
               //}
               if (Bid - OrderOpenPrice() > byPips * MarketInfo(OrderSymbol(), MODE_POINT)) {
                  if (OrderStopLoss() < Bid - byPips * MarketInfo(OrderSymbol(), MODE_POINT)) {
                     OrderModify(OrderTicket(), OrderOpenPrice(), Bid - byPips * MarketInfo(OrderSymbol(), MODE_POINT), OrderTakeProfit(), Red);
                  }
               }
            } else if (OrderType() == OP_SELL) {
               if (OrderOpenPrice() - Ask > byPips * MarketInfo(OrderSymbol(), MODE_POINT)) {
                  if ((OrderStopLoss() > Ask + byPips * MarketInfo(OrderSymbol(), MODE_POINT)) ||
                        (OrderStopLoss() == 0)) {
                     OrderModify(OrderTicket(), OrderOpenPrice(),
                        Ask + byPips * MarketInfo(OrderSymbol(), MODE_POINT), OrderTakeProfit(), Red);
                  }
               }
            }
        }
      }
      }

  } // proc TrailIt()


//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
int start()
  {
//----
   int    i, j,k, ticket, entermode, totalorders;
   bool   doit;
   double point, startrate, traderate, temp;
//---- setup parameters

 if ( TakeProfit <= 0 )                 //
   { TakeProfit = GridSize; }

 bool myWantLongs = wantLongs;
 bool myWantShorts = wantShorts;

//---- test if we want to shutdown or suspend
   if (suspendGrid == true) {       // close unfilled orders and then test if profit target
      CloseAllPendingOrders();
   }
   if (shutdownGrid == true) {      // close all positions and orders. then exit.. there is nothing more to do
      ClosePendingOrdersAndPositions();
      return(0);
   }
   if (haveHitTarget == true) {     // in case we hit target and there are still some open orders and positions
      ClosePendingOrdersAndPositions();
      if (gridOneShot==true) { gridActive = false; }
   }
//----
   if (gridActive == false) {       // if grid not active, do nothing.
     return(0);
   }

//----

  if (MathAbs(CurTime()-LastUpdate)> UpdateInterval*60)           // we update the first time it is called and every UpdateInterval minutes
   {
  
   if (profitTarget >0)
      {
        TestForProfit(uniqueGridMagic, profitTarget, true, false );
        if (!IsTesting()) {
            Comment(" v 1.93  "," Server time is ",TimeToStr(CurTime( )),
               "\n",
//               "\n","                  Closed p&l  = ",closedProfit,
               "\n","                  Open p&l    = ",openProfit,
//               "\n","                  Total p&l   = ",closedProfit + openProfit, 
               "\n","                  Long, Short = ",openLongs,"  ",openShorts,
               "\n","                  Net pos     = ",openLongs-openShorts,
               "\n",
               "\n","                  Balance     = ",AccountBalance(),
               "\n","                  Equity      = ",AccountEquity(),
               "\n","                  Margin      = ",AccountMargin(),
               "\n","                  Free mrg    = ",AccountFreeMargin(),
               ());
            }
      }

  
  
   LastUpdate = CurTime();
   point = MarketInfo(Symbol(),MODE_POINT);
   startrate = ( Ask + point*GridSize/2 ) / point / GridSize;    // round to a number of ticks divisible by GridSize
   k = startrate ;
   k = k * GridSize ;
   startrate = k * point - GridSize*GridSteps/2*point ;          // calculate the lowest entry point
   double myEMA=iMA(NULL,0,EMAperiod,0,MODE_EMA,PRICE_CLOSE,0);
   int currentOpen = 0;
   if ( GridMaxOpen > 0 ) {
      currentOpen = openPositions();
      if (currentOpen >= GridMaxOpen) {CloseAllPendingOrders(); }
   }
  
   if (limitEMA) { if (doHouseKeeping) CloseOrdersfromEMA(myEMA);}
   if (keepOpenTimeLimit > 0) DeleteAfter(keepOpenTimeLimit);
   if (trailStop >0) TrailIt(trailStop);
   if ( UseMACD || UseOsMA) 
     {
      if ( UseMACD )
        {
            double Trigger0=iMACD(NULL,timeFrame,emaFast,emaSlow,signalPeriod,PRICE_CLOSE,MODE_MAIN,0);
            double Trigger1=iMACD(NULL,timeFrame,emaFast,emaSlow,signalPeriod,PRICE_CLOSE,MODE_MAIN,1);
            double Trigger2=iMACD(NULL,timeFrame,emaFast,emaSlow,signalPeriod,PRICE_CLOSE,MODE_MAIN,2);
        }
      if ( UseOsMA )
        {
             Trigger0=iOsMA(NULL,timeFrame,emaFast,emaSlow,signalPeriod,PRICE_CLOSE,0);
             Trigger1=iOsMA(NULL,timeFrame,emaFast,emaSlow,signalPeriod,PRICE_CLOSE,1);
             Trigger2=iOsMA(NULL,timeFrame,emaFast,emaSlow,signalPeriod,PRICE_CLOSE,2);
        }

   
       if( (Trigger0 > 0) && (Trigger1 > 0)  &&  (Trigger2 < 0 ))     // cross up
        {
         CloseAllPendingOrders();
         if ( CloseOpenPositions == true ) { ClosePendingOrdersAndPositions(); }
        }
       if( (Trigger0<0) && (Trigger1<0)  &&  (Trigger2>0))     // cross down
        {
         CloseAllPendingOrders();
         if ( CloseOpenPositions == true ) { ClosePendingOrdersAndPositions(); }
        }
       myWantLongs = false;
       myWantShorts = false;
       if( (Trigger0>0) && (Trigger1>0)  &&  (Trigger2>0) && (wantLongs==true) )     // is well above zero
        {
         myWantLongs = true;
        }
       if( (Trigger0<0) && (Trigger1<0)  &&  (Trigger2<0) && (wantShorts== true) )     // is well below zero
        {
         myWantShorts = true;
        }
   }
   int myGridSteps = GridSteps;
   if (( GridMaxOpen > 0 ) && (currentOpen >= GridMaxOpen)) {
      myGridSteps = 0;
   }
  
    if (suspendGrid == true) {       //profit target and exit conditions tested so finished
      return(0);
   }

//   Print("Trigs ",    Trigger0,"  ",Trigger1,"  ",Trigger2,"  ",myWantLongs,"  ",myWantShorts,"  ",myGridSteps," ema ",myEMA," price ",Bid );

   //Print("start  1 ",startrate);    

   for( i=0;i<myGridSteps;i++) {

     startrate = ( Ask + point*GridSize/2 ) / point / GridSize;    // round to a number of ticks divisible by GridSize
     k = startrate ;
     k = k * GridSize ;
     startrate = k * point - GridSize*GridSteps/2*point ;          // calculate the lowest entry point
     traderate = startrate + i*point*GridSize + gridOffset*point;

     if (myWantLongs && (!limitEMA || traderate > myEMA)) {
          if (longGridCenter > point) {
               temp = GridSteps / 2;
               k = temp;
               startrate = longGridCenter - k * GridSize * point;
          }
          else {
               startrate = ( Ask + point*GridSize/2 ) / point / GridSize;    // round to a number of ticks divisible by GridSize
               k = startrate ;
               k = k * GridSize ;
               startrate = k * point - GridSize*GridSteps/2*point ;          // calculate the lowest entry point
          }

          traderate = startrate + i*point*GridSize + gridOffset*point;
          // now test if traderate within limits
          doit = true;
          if (traderate < longGridLow) {
                doit = false;
          }
          if ((traderate > longGridHigh) && (longGridHigh > point)) {
                doit = false;
          }
        
          if (( IsPosition(traderate,point*GridSize,true) == false ) && (doit == true)) {  // test if i have no open orders close to my price: if so, put one on

               double myStopLoss = 0;
               if ( StopLoss > 0 ) {
                    myStopLoss = traderate-point*StopLoss ;
               }
               if ( traderate > Ask ) {
               Print("BUY STOP",i);
                     entermode = OP_BUYSTOP;
               }
               else {
               Print("BUY LIMIT",i);
                     entermode = OP_BUYLIMIT ;
               }
               if ( ((traderate > (Ask +minFromPrice*Point) ) && (wantBreakout)) || ((traderate <= (Ask-minFromPrice*Point) ) && (wantCounter)) ) {
                     // modified by cori. Using OrderMagicNumber to identify the trades of the grid
                     ticket=OrderSend(Symbol(),entermode,Lots,traderate,0,myStopLoss,traderate+point*TakeProfit,GridName,uniqueGridMagic,0,Green);
               }
          }
      }
      if ( myWantShorts && (!limitEMA || traderate < myEMA)) {
          if (shortGridCenter > point) {
               temp = GridSteps / 2;
               k = temp;
               startrate = shortGridCenter - k * GridSize * point ;
          }
          else {
               startrate = ( Ask + point*GridSize/2 ) / point / GridSize;    // round to a number of ticks divisible by GridSize
               k = startrate ;
               k = k * GridSize ;
               startrate = k * point - GridSize*GridSteps/2*point ;          // calculate the lowest entry point
          }
    
          traderate = startrate + i*point*GridSize + gridOffset*point;
          // now test if traderate within limits
          doit = true;
    
          if (traderate < shortGridLow) {
              doit = false;
          }
          if ((traderate > shortGridHigh) && (shortGridHigh > point)) {
              doit = false;
          }

          if ((IsPosition(traderate,point*GridSize,false)== false ) && (doit == true)) {  // test if i have no open orders close to my price: if so, put one on
               myStopLoss = 0;
               if ( StopLoss > 0 ) {
                  myStopLoss = traderate+point*StopLoss ;
               }
               if ( traderate < Bid ) {
                  Print("SELL STOP",i);
                  entermode = OP_SELLSTOP;
               }
               else {
                  Print("SELL LIMIT",i);
                  entermode = OP_SELLLIMIT;
               }
               if ( ((traderate < (Bid -minFromPrice*Point) ) && (wantBreakout)) || ((traderate >= (Bid+minFromPrice*Point) ) && (wantCounter)) ) {
                // modified by cori. Using OrderMagicNumber to identify the trades of the grid
                ticket=OrderSend(Symbol(),entermode,Lots,traderate,0,myStopLoss,traderate-point*TakeProfit,GridName,uniqueGridMagic,0,Red);
               }
          }
       }
     }
   }
   return(0);
  }
//+------------------------------------------------------------------+

Temat wydzielony z:
Piramida użyta w forex konkursie BOSSY
------------------------------------------
[1] Robot napisany dla platformy MetaTrader4 (MT4), do znalezienia w popularnych wyszukiwarkach na hasło : "MakeGrid193".

# Prosty półautomat do budowania piramidy o stałej wielkości pozycji i stałej odległości

psV Grudzień 27, 2010, 12:04:12 am -------

Napisałem prosty półautomat do budowania piramidy o stałej wielkości pozycji i stałej odległości. Jest to wersja mocno niedoskonała, tak więc można jednocześnie grać tylko na jednym instrumencie.

Budowanie siatki następuje tuż po ręcznym zakupie/sprzedaży waloru. Po tym nie należy ręcznie już nic dokładać, bo robot zacznie głupieć. Ewentualnie można wystartować zleceniem typu limit, wtedy po aktywowaniu nastąpi budowanie piramidy.

Wyjście z pozycji:

• EA będzie automatycznie ustawiało SL na średnioważony BE. Po zburzeniu piramidy pozostały pending order zostanie skasowany.
• Zamknięcie na zysku ręcznie wedle uznania, celowo nie ustawiam TP.

Piramida BUY

extern double Lots         = 0.1;
extern int    Distance     = 50;
double Sum, SL0, SL1 = 0;
bool Init = True;
void start()
{
//   if(Init) {OrderSend(Symbol(),OP_BUY,Lots,Ask,0,0,0); Init = 0;}    //for testing
   if(OrdersTotal()==0) return;
   OpenPending();
   StopLoss();
   DeletePending();
}
void OpenPending()
{
   OrderSelect(OrdersTotal()-1, SELECT_BY_POS);
   if(OrderType()==OP_BUYSTOP) return;
   OrderSend(Symbol(),OP_BUYSTOP,Lots,OrderOpenPrice()+Distance*Point,0,0,0);
}
void StopLoss()
{
   if(OrdersTotal()<3) return;
   for(int i=0;i<OrdersTotal()-1;i++)
   {
      OrderSelect(i, SELECT_BY_POS);
      Sum = Sum + OrderOpenPrice();
   }
   SL0 = Sum/(OrdersTotal()-1);
   Sum = 0;
   if(SL0==SL1) return;
  
   for(i=0;i<OrdersTotal()-1;i++)
   {
      OrderSelect(i, SELECT_BY_POS);
      OrderModify(OrderTicket(), OrderOpenPrice(), SL0, OrderTakeProfit(), OrderExpiration());
   }
   SL1=SL0;
}
void DeletePending()
{
   if(OrdersTotal()==1)
   {
   OrderSelect(0, SELECT_BY_POS);
   OrderDelete(OrderTicket());
   PlaySound("ok.wav");
   }
}

Piramida SELL

extern double Lots         = 0.1;
extern int    Distance     = 50;
double Sum, SL0, SL1 = 0;
bool Init = True;
void start()
{
//   if(Init) {OrderSend(Symbol(),OP_SELL,Lots,Bid,0,0,0); Init = 0;}    //for testing
   if(OrdersTotal()==0) return;
   OpenPending();
   StopLoss();
   DeletePending();
}
void OpenPending()
{
   OrderSelect(OrdersTotal()-1, SELECT_BY_POS);
   if(OrderType()==OP_SELLSTOP) return;
   OrderSend(Symbol(),OP_SELLSTOP,Lots,OrderOpenPrice()-Distance*Point,0,0,0);
}
void StopLoss()
{
   if(OrdersTotal()<3) return;
   for(int i=0;i<OrdersTotal()-1;i++)
   {
      OrderSelect(i, SELECT_BY_POS);
      Sum = Sum + OrderOpenPrice();
   }
   SL0 = Sum/(OrdersTotal()-1);
   Sum = 0;
   if(SL0==SL1) return;
   for(i=0;i<OrdersTotal()-1;i++)
   {
      OrderSelect(i, SELECT_BY_POS);
      OrderModify(OrderTicket(), OrderOpenPrice(), SL0, OrderTakeProfit(), OrderExpiration());
   }
   SL1=SL0;
}
void DeletePending()
{
   if(OrdersTotal()==1)
   {
   OrderSelect(0, SELECT_BY_POS);
   OrderDelete(OrderTicket());
   PlaySound("ok.wav");
   }
}

Grudzień 28, 2010, 10:01:44 am -------
Gra bez TP
 

Skoro nie ustawiasz TP to może pomyśl o jakimś TS - powiedzmy zgodnym z rozstawem zleceń czyli 50 pipsów - w przypadku niekorzystnego ruchu masz szansę coś urwać przed BE.

Dla piramidy składającej się z 2 jednakowych zleceń możesz w uproszczeniu założyć, że minimalne TP licząc od poziomu pierwszego zlecenia  powinno być nie mniejsze niż 3krotność rozstawu + 3krotność spread'u. W przypadku jeśli na 3 nieudane starty piramidy przypadnie 1 udany będziesz mógł liczyć przy takim TP na wyjście "na 0". Czyli w tym przypadku minimalny TP to jakieś 80 pipów od średnioważonego BE. W praktyce dla całego systemu uwzględniającego udane jak i nieudane piramidy tak ustawione TP będzie dopiero średnioważonym BE.

Dla piramidy 3zleceniowej wypada już przyjąć 5-6krotność rozstawu + 5-6krotoność spread'u dla poszukiwań minimalnego TP.

Dla uzyskania bardziej precyzyjnych parametrów można zamiast rozstawu przyjąć średnią stratę z nieudanych startów piramid *1,15, a spread (jako niewiadomą z pewnego obszaru zmienności) wyznaczyć dla bezpieczeństwa jako najczęściej występujący spread *1,5.

Temat wydzielony z:
Piramida użyta w forex konkursie BOSSY