void RangeSlider::calculatePositions(int& left, int& right) const { int w = getSize().x; int hw = lHandle_->getSize().x; left = round_pos(lValue_ * (w - hw - 2)) + 1; right = round_pos(rValue_ * (w - hw - 2)) + 1; }
const Point& RangeSlider::setSize(float width, float height) { const Point& newSize = AbstractSliderBase::setSize(width, height); float hdlW = std::max(round_pos(newSize.x * .05f), handleSize_); lHandle_->setSize(hdlW, newSize.y - 2); rHandle_->setSize(hdlW, newSize.y - 2); int lx, rx; calculatePositions(lx, rx); lHandle_->setPos(lx, 1); rHandle_->setPos(rx, 1); updateRangeBar(); return newSize; }
RangeSlider::RangeSlider( const Point& pos, const Point& size, const float range[2], MapType mapType, const char* colorScheme) : AbstractSliderBase(pos, size, range, mapType, colorScheme), handleSize_(3) { lValue_ = 0.f; rValue_ = 1.f; float hdlW = std::max(round_pos(size.x * .05f), handleSize_); Point hdlSize(hdlW, size.y - 2); lHandle_ = new WiBox(Point(1, 1), hdlSize); rHandle_ = new WiBox(Point(size.x - 1 - hdlSize.x, 1), hdlSize); GuiObject* obj[] = { lHandle_, rHandle_ }; for (int i = 0; i != 2; ++i) { obj[i]->addDraggedListener(this); obj[i]->setDraggable(); obj[i]->setDraggableArea(0, Point(1, 1)); } rangeBar_ = new WiBox(Point(), Point()); GuiObject* obj2[] = { rangeBar_, lHandle_, rHandle_ }; for (int i = 0; i != 3; ++i) { addSubObject(obj2[i]); obj2[i]->setEmbedded(); obj2[i]->addMouseListener(this); } addMouseListener(this); updateRangeBar(); setColors(colorScheme); }
TA_RetCode TA_ADX( TA_Libc *libHandle, TA_Integer startIdx, TA_Integer endIdx, const TA_Real inHigh_0[], const TA_Real inLow_0[], const TA_Real inClose_0[], TA_Integer optInTimePeriod_0, /* From 1 to TA_INTEGER_MAX */ TA_Integer *outBegIdx, TA_Integer *outNbElement, TA_Real outReal_0[] ) /**** END GENCODE SECTION 2 - DO NOT DELETE THIS LINE ****/ { /* insert local variable here */ TA_Integer today, lookbackTotal, outIdx; TA_Real prevHigh, prevLow, prevClose; TA_Real prevMinusDM, prevPlusDM, prevTR; TA_Real tempReal, tempReal2, diffP, diffM; TA_Real minusDI, plusDI, sumDX, prevADX; int i; #define TRUE_RANGE(TH,TL,YC,OUT) {\ OUT = TH-TL; \ tempReal2 = fabs(TH-YC); \ if( tempReal2 > OUT ) \ OUT = tempReal2; \ tempReal2 = fabs(TL-YC); \ if( tempReal2 > OUT ) \ OUT = tempReal2; \ } /**** START GENCODE SECTION 3 - DO NOT DELETE THIS LINE ****/ (void)libHandle; /* Get ride of warning if unused. */ #ifndef TA_FUNC_NO_RANGE_CHECK /* Validate the requested output range. */ if( startIdx < 0 ) return TA_OUT_OF_RANGE_START_INDEX; if( (endIdx < 0) || (endIdx < startIdx)) return TA_OUT_OF_RANGE_END_INDEX; /* Validate the parameters. */ /* Verify required price component. */ if(!inHigh_0||!inLow_0||!inClose_0) return TA_BAD_PARAM; /* min/max are checked for optInTimePeriod_0. */ if( optInTimePeriod_0 == TA_INTEGER_DEFAULT ) optInTimePeriod_0 = 14; else if( (optInTimePeriod_0 < 1) || (optInTimePeriod_0 > 2147483647) ) return TA_BAD_PARAM; if( outReal_0 == NULL ) return TA_BAD_PARAM; #endif /* TA_FUNC_NO_RANGE_CHECK */ /**** END GENCODE SECTION 3 - DO NOT DELETE THIS LINE ****/ /* Insert TA function code here. */ /* * The DM1 (one period) is base on the largest part of * today's range that is outside of yesterdays range. * * The following 7 cases explain how the +DM and -DM are * calculated on one period: * * Case 1: Case 2: * C| A| * | | C| * | +DM1 = (C-A) B| | +DM1 = 0 * | -DM1 = 0 | -DM1 = (B-D) * A| | D| * | D| * B| * * Case 3: Case 4: * C| C| * | A| | * | +DM1 = (C-A) | | +DM1 = 0 * | -DM1 = 0 B| | -DM1 = (B-D) * A| | | * | | D| * B| | * D| * * Case 5: Case 6: * A| A| C| * | C| +DM1 = 0 | | +DM1 = 0 * | | -DM1 = 0 | | -DM1 = 0 * | D| | | * B| B| D| * * * Case 7: * * C| * A| | * | | +DM=0 * B| | -DM=0 * D| * * In case 3 and 4, the rule is that the smallest delta between * (C-A) and (B-D) determine which of +DM or -DM is zero. * * In case 7, (C-A) and (B-D) are equal, so both +DM and -DM are * zero. * * The rules remain the same when A=B and C=D (when the highs * equal the lows). * * When calculating the DM over a period > 1, the one-period DM * for the desired period are initialy sum. In other word, * for a -DM14, sum the -DM1 for the first 14 days (that's * 13 values because there is no DM for the first day!) * Subsequent DM are calculated using the Wilder's * smoothing approach: * * Previous -DM14 * Today's -DM14 = Previous -DM14 - -------------- + Today's -DM1 * 14 * * (Same thing for +DM14) * * Calculation of a -DI14 is as follow: * * -DM14 * -DI14 = -------- * TR14 * * (Same thing for +DI14) * * Calculation of the TR14 is: * * Previous TR14 * Today's TR14 = Previous TR14 - -------------- + Today's TR1 * 14 * * The first TR14 is the summation of the first 14 TR1. See the * TA_TRANGE function on how to calculate the true range. * * Calculation of the DX14 is: * * diffDI = ABS( (-DI14) - (+DI14) ) * sumDI = (-DI14) + (+DI14) * * DX14 = 100 * (diffDI / sumDI) * * (Note: The DX is rounded) * * Calculation of the first ADX: * * ADX14 = SUM of the first 14 DX * * Calculation of subsequent ADX: * * ((Previous ADX14)*(14-1))+ Today's DX * ADX14 = ------------------------------------- * 14 * * (Note: The ADX is rounded) * * Reference: * New Concepts In Technical Trading Systems, J. Welles Wilder Jr */ if( optInTimePeriod_0 > 1 ) lookbackTotal = (2*optInTimePeriod_0) + TA_UnstablePeriodTable[TA_FUNC_UNST_ADX] - 1; else lookbackTotal = 2; /* Adjust startIdx to account for the lookback period. */ if( startIdx < lookbackTotal ) startIdx = lookbackTotal; /* Make sure there is still something to evaluate. */ if( startIdx > endIdx ) { *outBegIdx = 0; *outNbElement = 0; return TA_SUCCESS; } /* Indicate where the next output should be put * in the outReal_0. */ outIdx = 0; /* Process the initial DM and TR */ *outBegIdx = today = startIdx; prevMinusDM = 0.0; prevPlusDM = 0.0; prevTR = 0.0; today = startIdx - lookbackTotal; prevHigh = inHigh_0[today]; prevLow = inLow_0[today]; prevClose = inClose_0[today]; i = optInTimePeriod_0-1; while( i-- > 0 ) { /* Calculate the prevMinusDM and prevPlusDM */ today++; tempReal = inHigh_0[today]; diffP = tempReal-prevHigh; /* Plus Delta */ prevHigh = tempReal; tempReal = inLow_0[today]; diffM = prevLow-tempReal; /* Minus Delta */ prevLow = tempReal; if( (diffM > 0) && (diffP < diffM) ) { /* Case 2 and 4: +DM=0,-DM=diffM */ prevMinusDM += diffM; } else if( (diffP > 0) && (diffP > diffM) ) { /* Case 1 and 3: +DM=diffP,-DM=0 */ prevPlusDM += diffP; } TRUE_RANGE(prevHigh,prevLow,prevClose,tempReal); prevTR += tempReal; prevClose = inClose_0[today]; } /* Add up all the initial DX. */ sumDX = 0.0; i = optInTimePeriod_0; while( i-- > 0 ) { /* Calculate the prevMinusDM and prevPlusDM */ today++; tempReal = inHigh_0[today]; diffP = tempReal-prevHigh; /* Plus Delta */ prevHigh = tempReal; tempReal = inLow_0[today]; diffM = prevLow-tempReal; /* Minus Delta */ prevLow = tempReal; prevMinusDM -= prevMinusDM/optInTimePeriod_0; prevPlusDM -= prevPlusDM/optInTimePeriod_0; if( (diffM > 0) && (diffP < diffM) ) { /* Case 2 and 4: +DM=0,-DM=diffM */ prevMinusDM += diffM; } else if( (diffP > 0) && (diffP > diffM) ) { /* Case 1 and 3: +DM=diffP,-DM=0 */ prevPlusDM += diffP; } /* Calculate the prevTR */ TRUE_RANGE(prevHigh,prevLow,prevClose,tempReal); prevTR = prevTR - (prevTR/optInTimePeriod_0) + tempReal; prevClose = inClose_0[today]; /* Calculate the DX. The value is rounded (see Wilder book). */ minusDI = round_pos(100.0*(prevMinusDM/prevTR)); plusDI = round_pos(100.0*(prevPlusDM/prevTR)); /* This loop is just to accumulate the initial DX */ sumDX += round_pos( 100.0 * (fabs(minusDI-plusDI)/(minusDI+plusDI)) ); } /* Calculate the first ADX */ prevADX = round_pos( sumDX / optInTimePeriod_0 ); /* Skip the unstable period */ i = TA_UnstablePeriodTable[TA_FUNC_UNST_ADX]; while( i-- > 0 ) { /* Calculate the prevMinusDM and prevPlusDM */ today++; tempReal = inHigh_0[today]; diffP = tempReal-prevHigh; /* Plus Delta */ prevHigh = tempReal; tempReal = inLow_0[today]; diffM = prevLow-tempReal; /* Minus Delta */ prevLow = tempReal; prevMinusDM -= prevMinusDM/optInTimePeriod_0; prevPlusDM -= prevPlusDM/optInTimePeriod_0; if( (diffM > 0) && (diffP < diffM) ) { /* Case 2 and 4: +DM=0,-DM=diffM */ prevMinusDM += diffM; } else if( (diffP > 0) && (diffP > diffM) ) { /* Case 1 and 3: +DM=diffP,-DM=0 */ prevPlusDM += diffP; } /* Calculate the prevTR */ TRUE_RANGE(prevHigh,prevLow,prevClose,tempReal); prevTR = prevTR - (prevTR/optInTimePeriod_0) + tempReal; prevClose = inClose_0[today]; /* Calculate the DX. The value is rounded (see Wilder book). */ minusDI = round_pos(100.0*(prevMinusDM/prevTR)); plusDI = round_pos(100.0*(prevPlusDM/prevTR)); tempReal = round_pos(100.0*(fabs(minusDI-plusDI)/(minusDI+plusDI))); /* Calculate the ADX */ prevADX = round_pos(((prevADX*(optInTimePeriod_0-1))+tempReal)/optInTimePeriod_0); } /* Output the first ADX */ outReal_0[0] = prevADX; outIdx = 1; /* Calculate and output subsequent ADX */ while( today < endIdx ) { /* Calculate the prevMinusDM and prevPlusDM */ today++; tempReal = inHigh_0[today]; diffP = tempReal-prevHigh; /* Plus Delta */ prevHigh = tempReal; tempReal = inLow_0[today]; diffM = prevLow-tempReal; /* Minus Delta */ prevLow = tempReal; prevMinusDM -= prevMinusDM/optInTimePeriod_0; prevPlusDM -= prevPlusDM/optInTimePeriod_0; if( (diffM > 0) && (diffP < diffM) ) { /* Case 2 and 4: +DM=0,-DM=diffM */ prevMinusDM += diffM; } else if( (diffP > 0) && (diffP > diffM) ) { /* Case 1 and 3: +DM=diffP,-DM=0 */ prevPlusDM += diffP; } /* Calculate the prevTR */ TRUE_RANGE(prevHigh,prevLow,prevClose,tempReal); prevTR = prevTR - (prevTR/optInTimePeriod_0) + tempReal; prevClose = inClose_0[today]; /* Calculate the DX. The value is rounded (see Wilder book). */ minusDI = round_pos(100.0*(prevMinusDM/prevTR)); plusDI = round_pos(100.0*(prevPlusDM/prevTR)); tempReal = round_pos(100.0*(fabs(minusDI-plusDI)/(minusDI+plusDI))); /* Calculate and output the ADX */ prevADX = round_pos(((prevADX*(optInTimePeriod_0-1))+tempReal)/optInTimePeriod_0); outReal_0[outIdx++] = prevADX; } *outNbElement = outIdx; return TA_SUCCESS; }