['   \n  \n [\'#what ਨੂੰ ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ \\n\\ਨਿਮਪੋਰਟ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. \\ਨਿਮਪੋਰਟ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ. ਦੇ ਰੂਪ ਵਿੱਚ, ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. \\ਨਿਮਪੋਰਟ ਟਾ ਦੇ ਰੂਪ ਵਿੱਚ, ਚੇਤਾਵਨੀਆਂ।\\ nwarnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") \\n\\nequity = 100000\\n\\ndef rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30,rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20, adx _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): \\n #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-\\n ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\\\'rsi\\\'] =ta.momentum.RSIIndicator (ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () \\n adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\\\'ਉੱਚ\'], ਡਾਟਾ [\\\'ਘੱਟ\'],ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\\\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) \\n ਡਾਟਾ [\\\'adx\\\'] = adx_indicator.adx () \\n ਡਾਟਾ [\\\'ti _ poss\\\'] = adx_indicator.adx _ poss () \\n ਡਾਟਾ [\\\'ti _ neg\\\'] =adx_indicator.adx_neg () \\n\\n #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋ \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\'] = 0\\n ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\'] = 0\\n ਵਿੱਚ i ਲਈਰੇਂਜ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ \\n #ਸਿਗਨਲ ਖਰੀਦੋ \\n ਜੇਕਰ ਡਾਟਾ [\\\'rsi\\\']. iloc [i] <rsi _ oversold ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇਡਾਟਾ [\\\'ਡਾਇਆ _ ਪੋਜ਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼ਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 1\\n ਇਕੁਇਟੀ + = 1\\n\\n #ਸਿਗਨਲ ਵੇਚੋ\\n ਐਲੀਫ ਡਾਟਾ [\\\'rsi\\\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]>ਐਡਐਕਸ _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ ਅਤੇ ਡੇਟਾ [\\\'ਡਿ _ ਪੋਸ\\\']. ਇਲੋਕ [i] <ਡੇਟਾ [\\\'ਡਿ _ ਨੈਗ\\\']. ਇਲੋਕ [i]: \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\']. ਇਲੋਕ [i] =-1 \\n ਜੇਕਰ ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\']. ਇਲੋਕ [i-1] = = 1: \\nਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 0\\n ਇਕੁਇਟੀ-= 1\\n\\n \'] ', '#what ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. ਆਯਾਤ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ., ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. ਆਯਾਤ ਟਾ, ਚੇਤਾਵਨੀਆਂ warnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") ਦੇ ਰੂਪ ਵਿੱਚ ਆਯਾਤ ਕਰੋ।ਇਕੁਇਟੀ = 100000 ਡਿਫ rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30, rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20,adx _ take _ ਲਾਭ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\'rsi\'] = ta.momentum.RSIIndicator (ਡੇਟਾ [\'ਬੰਦ ਕਰੋ\'],ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\'ਉੱਚ\'], ਡਾਟਾ [\'ਘੱਟ\'], ਡਾਟਾ [\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) ਡਾਟਾ [\'adx\'] =adx_indicator.adx () ਡਾਟਾ [\'ਡਿ _ ਪੋਸ\'] = adx_indicator.adx _ ਪੋਸ () ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\'] = adx_indicator.adx _ ਨੈਗ () #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋਡਾਟਾ [\'ਸਿਗਨਲ\'] = 0 ਡਾਟਾ [\'ਪੋਜੀਸ਼ਨ\'] = 0 i ਲਈ ਰੇਂਜ ਵਿੱਚ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ #ਸਿਗਨਲ ਖਰੀਦੋ ਜੇਕਰ ਡਾਟਾ [\'rsi\'] ਹੈ।ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇ ਡਾਟਾ [\'Di _ poss\']. iloc [i]> ਡਾਟਾ [\'Di _ neg\']. iloc [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. iloc [i] = 1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i-1] = =0: ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i] = 1 ਇਕੁਇਟੀ + = 1 #ਸਿਗਨਲ ਐਲੀਫ ਡਾਟਾ [\'rsi\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ take _ ਲਾਭ ਅਤੇਡਾਟਾ [\'ਡਿ _ ਪੋਸ\']. ਆਈਲੋਕ [i] <ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\']. ਆਈਲੋਕ [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. ਆਈਲੋਕ [i] =-1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i-1] = = 1: ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i] = 0 ਇਕੁਇਟੀ- = 1', ' [\'#what ਨੂੰ ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ \\n\\ਨਿਮਪੋਰਟ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. \\ਨਿਮਪੋਰਟ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ. ਦੇ ਰੂਪ ਵਿੱਚ, ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. \\ਨਿਮਪੋਰਟ ਟਾ ਦੇ ਰੂਪ ਵਿੱਚ, ਚੇਤਾਵਨੀਆਂ।\\ nwarnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") \\n\\nequity = 100000\\n\\ndef rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30,rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20, adx _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): \\n #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-\\n ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\\\'rsi\\\'] =ta.momentum.RSIIndicator (ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () \\n adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\\\'ਉੱਚ\'], ਡਾਟਾ [\\\'ਘੱਟ\'],ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\\\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) \\n ਡਾਟਾ [\\\'adx\\\'] = adx_indicator.adx () \\n ਡਾਟਾ [\\\'ti _ poss\\\'] = adx_indicator.adx _ poss () \\n ਡਾਟਾ [\\\'ti _ neg\\\'] =adx_indicator.adx_neg () \\n\\n #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋ \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\'] = 0\\n ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\'] = 0\\n ਵਿੱਚ i ਲਈਰੇਂਜ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ \\n #ਸਿਗਨਲ ਖਰੀਦੋ \\n ਜੇਕਰ ਡਾਟਾ [\\\'rsi\\\']. iloc [i] <rsi _ oversold ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇਡਾਟਾ [\\\'ਡਾਇਆ _ ਪੋਜ਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼ਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 1\\n ਇਕੁਇਟੀ + = 1\\n\\n #ਸਿਗਨਲ ਵੇਚੋ\\n ਐਲੀਫ ਡਾਟਾ [\\\'rsi\\\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]>ਐਡਐਕਸ _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ ਅਤੇ ਡੇਟਾ [\\\'ਡਿ _ ਪੋਸ\\\']. ਇਲੋਕ [i] <ਡੇਟਾ [\\\'ਡਿ _ ਨੈਗ\\\']. ਇਲੋਕ [i]: \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\']. ਇਲੋਕ [i] =-1 \\n ਜੇਕਰ ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\']. ਇਲੋਕ [i-1] = = 1: \\nਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 0\\n ਇਕੁਇਟੀ-= 1\\n\\n \', "ਕੁੱਝ ਖੇਤਰ ਹਨ ਜੋ ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨਃ \\n\\n1।ਸਿਰਫ ਆਖਰੀ \'rsi _ ਪੀਰੀਅਡ-1\' ਕਤਾਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਸੋਧਿਆ ਗਿਆ ਹੈ, ਜਿਸ ਨੂੰ ਸਿਰਫ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਕਤਾਰ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਘਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜੇ RSI ਮੁੱਲ ਨਹੀਂ ਹੈਕਤਾਰਾਂ ਵਿਚਕਾਰ ਮਹੱਤਵਪੂਰਨ ਤਬਦੀਲੀ. \\n2. \'ਜੇਕਰ\' ਬਿਆਨ ਜੋ ਇਹ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਕਤਾਰ ਲੂਪ ਦੀ ਪਹਿਲੀ ਕਤਾਰ ਹੈ, ਨੂੰ ਕਤਾਰ ਤੋਂ ਬਾਹਰ ਲਿਜਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਲਈ ਲੂਪ। \\n3. ਹਰੇਕ ਕਤਾਰ ਲਈ \'ਡੇਟਾ [\' ਸਥਿਤੀ \']\' ਅਤੇ \'ਡੇਟਾ [\' ਸੰਕੇਤ \']\' ਕਾਲਮਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਲਈ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਹੈ।ਵੱਡੇ ਡੇਟਾਸੇਟ। ਲੂਪ ਤੋਂ ਬਾਹਰ ਇਹਨਾਂ ਮੁੱਲਾਂ ਦੀ ਪੂਰਵ-ਗਣਨਾ ਕਰਨਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਉਦੋਂ ਹੀ ਅੱਪਡੇਟ ਕਰਨਾ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਸੰਕੇਤ ਜਾਂ ਸਥਿਤੀ ਹੋਵੇ।ਤਬਦੀਲੀਆਂ. \\n4. \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜੋ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਸਥਿਤੀ 0 ਤੋਂ 1 (ਜਾਂ ਇਸਦੇ ਉਲਟ) ਵਿੱਚ ਬਦਲ ਰਹੀ ਹੈ, ਨੂੰ ਇੱਕ ਸਿੰਗਲ \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਇਹ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਸਥਿਤੀ ਬਦਲ ਰਹੀ ਹੈ ਜਾਂ ਨਹੀਂ, ਜੋ ਤੁਲਨਾ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਏਗੀ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗੀ। \\n5. \'ਇਕੁਇਟੀ\' ਵੇਰੀਏਬਲ ਹੋ ਸਕਦਾ ਹੈਲੂਪ ਦੇ ਬਾਹਰ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਇਸ ਨੂੰ ਹਰ ਕਤਾਰ ਲਈ ਮੁਡ਼ ਗਿਣਤੀ ਤੋਂ ਬਚਾਇਆ ਜਾ ਸਕੇ। \\n6. ਕੋਡ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ \'mp.Process\' ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੈਰਲਲਾਈਜ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਈਮ। ਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਸ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵਿੱਚ ਗਣਨਾਵਾਂ ਅਤੇ ਤੁਲਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣਾ, ਬਾਹਰਲੇ ਮੁੱਲਾਂ ਦੀ ਪੂਰਵ-ਗਣਨਾ ਕਰਨਾ ਸ਼ਾਮਲ ਹੋ ਸਕਦਾ ਹੈ।ਲੂਪ ਦਾ, ਅਤੇ ਤੇਜ਼ੀ ਨਾਲ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ ਕੋਡ ਨੂੰ ਪੈਰਲਲਾਈਜ਼ ਕਰਨਾ. \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਸਾਰੇ ਇੰਪੁੱਟ ਨਾਲ ਦੁਬਾਰਾ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਮੈਨੂੰ ਦਿੱਤਾ ਹੈ \'] ', '#what ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. ਆਯਾਤ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ., ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. ਆਯਾਤ ਟਾ, ਚੇਤਾਵਨੀਆਂ warnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") ਦੇ ਰੂਪ ਵਿੱਚ ਆਯਾਤ ਕਰੋ।ਇਕੁਇਟੀ = 100000 ਡਿਫ rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30, rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20,adx _ take _ ਲਾਭ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\'rsi\'] = ta.momentum.RSIIndicator (ਡੇਟਾ [\'ਬੰਦ ਕਰੋ\'],ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\'ਉੱਚ\'], ਡਾਟਾ [\'ਘੱਟ\'], ਡਾਟਾ [\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) ਡਾਟਾ [\'adx\'] =adx_indicator.adx () ਡਾਟਾ [\'ਡਿ _ ਪੋਸ\'] = adx_indicator.adx _ ਪੋਸ () ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\'] = adx_indicator.adx _ ਨੈਗ () #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋਡਾਟਾ [\'ਸਿਗਨਲ\'] = 0 ਡਾਟਾ [\'ਪੋਜੀਸ਼ਨ\'] = 0 i ਲਈ ਰੇਂਜ ਵਿੱਚ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ #ਸਿਗਨਲ ਖਰੀਦੋ ਜੇਕਰ ਡਾਟਾ [\'rsi\'] ਹੈ।ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇ ਡਾਟਾ [\'Di _ poss\']. iloc [i]> ਡਾਟਾ [\'Di _ neg\']. iloc [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. iloc [i] = 1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i-1] = =0: ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i] = 1 ਇਕੁਇਟੀ + = 1 #ਸਿਗਨਲ ਐਲੀਫ ਡਾਟਾ [\'rsi\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ take _ ਲਾਭ ਅਤੇਡਾਟਾ [\'ਡਿ _ ਪੋਸ\']. ਆਈਲੋਕ [i] <ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\']. ਆਈਲੋਕ [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. ਆਈਲੋਕ [i] =-1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i-1] = = 1: ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i] = 0 ਇਕੁਇਟੀ- = 1', ' [\'#what ਨੂੰ ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ \\n\\ਨਿਮਪੋਰਟ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. \\ਨਿਮਪੋਰਟ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ. ਦੇ ਰੂਪ ਵਿੱਚ, ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. \\ਨਿਮਪੋਰਟ ਟਾ ਦੇ ਰੂਪ ਵਿੱਚ, ਚੇਤਾਵਨੀਆਂ।\\ nwarnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") \\n\\nequity = 100000\\n\\ndef rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30,rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20, adx _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): \\n #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-\\n ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\\\'rsi\\\'] =ta.momentum.RSIIndicator (ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () \\n adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\\\'ਉੱਚ\'], ਡਾਟਾ [\\\'ਘੱਟ\'],ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\\\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) \\n ਡਾਟਾ [\\\'adx\\\'] = adx_indicator.adx () \\n ਡਾਟਾ [\\\'ti _ poss\\\'] = adx_indicator.adx _ poss () \\n ਡਾਟਾ [\\\'ti _ neg\\\'] =adx_indicator.adx_neg () \\n\\n #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋ \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\'] = 0\\n ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\'] = 0\\n ਵਿੱਚ i ਲਈਰੇਂਜ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ \\n #ਸਿਗਨਲ ਖਰੀਦੋ \\n ਜੇਕਰ ਡਾਟਾ [\\\'rsi\\\']. iloc [i] <rsi _ oversold ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇਡਾਟਾ [\\\'ਡਾਇਆ _ ਪੋਜ਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼ਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 1\\n ਇਕੁਇਟੀ + = 1\\n\\n #ਸਿਗਨਲ ਵੇਚੋ\\n ਐਲੀਫ ਡਾਟਾ [\\\'rsi\\\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]>ਐਡਐਕਸ _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ ਅਤੇ ਡੇਟਾ [\\\'ਡਿ _ ਪੋਸ\\\']. ਇਲੋਕ [i] <ਡੇਟਾ [\\\'ਡਿ _ ਨੈਗ\\\']. ਇਲੋਕ [i]: \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\']. ਇਲੋਕ [i] =-1 \\n ਜੇਕਰ ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\']. ਇਲੋਕ [i-1] = = 1: \\nਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 0\\n ਇਕੁਇਟੀ-= 1\\n\\n \', "ਕੁੱਝ ਖੇਤਰ ਹਨ ਜੋ ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨਃ \\n\\n1।ਸਿਰਫ ਆਖਰੀ \'rsi _ ਪੀਰੀਅਡ-1\' ਕਤਾਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਸੋਧਿਆ ਗਿਆ ਹੈ, ਜਿਸ ਨੂੰ ਸਿਰਫ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਕਤਾਰ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਘਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜੇ RSI ਮੁੱਲ ਨਹੀਂ ਹੈਕਤਾਰਾਂ ਵਿਚਕਾਰ ਮਹੱਤਵਪੂਰਨ ਤਬਦੀਲੀ. \\n2. \'ਜੇਕਰ\' ਬਿਆਨ ਜੋ ਇਹ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਕਤਾਰ ਲੂਪ ਦੀ ਪਹਿਲੀ ਕਤਾਰ ਹੈ, ਨੂੰ ਕਤਾਰ ਤੋਂ ਬਾਹਰ ਲਿਜਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਲਈ ਲੂਪ। \\n3. ਹਰੇਕ ਕਤਾਰ ਲਈ \'ਡੇਟਾ [\' ਸਥਿਤੀ \']\' ਅਤੇ \'ਡੇਟਾ [\' ਸੰਕੇਤ \']\' ਕਾਲਮਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਲਈ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਹੈ।ਵੱਡੇ ਡੇਟਾਸੇਟ। ਲੂਪ ਤੋਂ ਬਾਹਰ ਇਹਨਾਂ ਮੁੱਲਾਂ ਦੀ ਪੂਰਵ-ਗਣਨਾ ਕਰਨਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਉਦੋਂ ਹੀ ਅੱਪਡੇਟ ਕਰਨਾ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਸੰਕੇਤ ਜਾਂ ਸਥਿਤੀ ਹੋਵੇ।ਤਬਦੀਲੀਆਂ. \\n4. \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜੋ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਸਥਿਤੀ 0 ਤੋਂ 1 (ਜਾਂ ਇਸਦੇ ਉਲਟ) ਵਿੱਚ ਬਦਲ ਰਹੀ ਹੈ, ਨੂੰ ਇੱਕ ਸਿੰਗਲ \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਇਹ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਸਥਿਤੀ ਬਦਲ ਰਹੀ ਹੈ ਜਾਂ ਨਹੀਂ, ਜੋ ਤੁਲਨਾ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਏਗੀ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗੀ। \\n5. \'ਇਕੁਇਟੀ\' ਵੇਰੀਏਬਲ ਹੋ ਸਕਦਾ ਹੈਲੂਪ ਦੇ ਬਾਹਰ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਇਸ ਨੂੰ ਹਰ ਕਤਾਰ ਲਈ ਮੁਡ਼ ਗਿਣਤੀ ਤੋਂ ਬਚਾਇਆ ਜਾ ਸਕੇ। \\n6. ਕੋਡ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ \'mp.Process\' ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੈਰਲਲਾਈਜ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਈਮ। ਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਸ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵਿੱਚ ਗਣਨਾਵਾਂ ਅਤੇ ਤੁਲਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣਾ, ਬਾਹਰਲੇ ਮੁੱਲਾਂ ਦੀ ਪੂਰਵ-ਗਣਨਾ ਕਰਨਾ ਸ਼ਾਮਲ ਹੋ ਸਕਦਾ ਹੈ।ਲੂਪ ਦਾ, ਅਤੇ ਤੇਜ਼ੀ ਨਾਲ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ ਕੋਡ ਨੂੰ ਪੈਰਲਲਾਈਜ਼ ਕਰਨਾ।, \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਸਾਰੇ ਇੰਪੁੱਟ ਨਾਲ ਦੁਬਾਰਾ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਮੈਨੂੰ ਦਿੱਤਾ ਹੈ \',\' ਯਕੀਨਨ, ਇੱਥੇ ਇੱਕ ਦੁਬਾਰਾ ਕੰਮ ਕੀਤਾ ਗਿਆ ਹੈ।ਕੋਡ ਦਾ ਸੰਸਕਰਣ ਜਿਸ ਵਿੱਚ ਉਹਨਾਂ ਸੁਝਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਮੈਂ ਪਹਿਲਾਂ ਜ਼ਿਕਰ ਕੀਤਾ ਹੈਃ \\n "\'ਪਾਈਥਨ \\ਨਿੰਪੋਰਟ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. \\ਨਿੰਪੋਰਟ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ. ਦੇ ਰੂਪ ਵਿੱਚ, ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. ਦੇ ਰੂਪ ਵਿੱਚ\\nimport ta, ਚੇਤਾਵਨੀਆਂ\\nwarnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") \\n\\nequity = 100000\\n\\ndef rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14,rsi _ ਓਵਰਸੋਲਡ = 30, rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20, adx _ take _ ਪ੍ਰੋਫਿਟ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): \\n #ਆਰ. ਐੱਸ. ਆਈ., ਏ. ਡੀ. ਐਕਸ., ਅਤੇ ਡੀ. ਆਈ. + ਅਤੇ ਡੀ. ਆਈ.-\\n ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\\\'rsi\\\'] =ta.momentum.RSIIndicator (ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () \\n adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\\\'ਉੱਚ\'], ਡਾਟਾ [\\\'ਘੱਟ\'],ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\\\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) \\n ਡਾਟਾ [\\\'adx\\\'] = adx_indicator.adx () \\n ਡਾਟਾ [\\\'ti _ poss\\\'] = adx_indicator.adx _ poss () \\n ਡਾਟਾ [\\\'ti _ neg\\\'] =adx_indicator.adx_neg () \\n\\n #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋ \\n ਸੰਕੇਤ = ਡਾਟਾ [\\\'rsi\\\']. ਸ਼ਿਫਟ (1) <rsi _ ਓਵਰਸੋਲਡ * np.ones (rsi _ ਪੀਰੀਅਡ) + (1 -rsi _ ਓਵਰਸੋਲਡ) * (ਡਾਟਾ [\\\'adx\\\']> adx _ ਰੀਲੋਡ) * np.ones (adx _ ਪੀਰੀਅਡ) \\n ਸਥਿਤੀਆਂ = np.zeros (ਲੇਨ (ਡਾਟਾ)) \\n ਸੀਮਾ ਵਿੱਚ i ਲਈ (adx _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): \\n ਜੇਕਰਸੰਕੇਤ [i-1] ਅਤੇ ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਪੋਸ\'] [i]> ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਨੈਗ\'] [i]: \\n ਸਥਿਤੀਆਂ [i] = 1\\n ਐਲੀਫ ਸੰਕੇਤ [i-1] ਅਤੇ ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਨੈਗ\'] [i]> ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਪੋਸ\'] [i]: \\nਸਥਿਤੀਆਂ [i] =-1 \\n ਐਲੀਫ ਸੰਕੇਤ [i-1] ਅਤੇ ਅੰਕਡ਼ੇ [\\\'adx\\\'] [i]> adx _ ਟੇਕ੍ _ ਪ੍ਰੋਫਿਟਃ \\n ਸਥਿਤੀਆਂ \',\' ਜਾਰੀ ਰੱਖੋ ਜਿੱਥੇ ਤੁਸੀਂ ਰੁਕਿਆ \'] ', '#what ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. ਆਯਾਤ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ., ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. ਆਯਾਤ ਟਾ, ਚੇਤਾਵਨੀਆਂ warnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") ਦੇ ਰੂਪ ਵਿੱਚ ਆਯਾਤ ਕਰੋ।ਇਕੁਇਟੀ = 100000 ਡਿਫ rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30, rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20,adx _ take _ ਲਾਭ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\'rsi\'] = ta.momentum.RSIIndicator (ਡੇਟਾ [\'ਬੰਦ ਕਰੋ\'],ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\'ਉੱਚ\'], ਡਾਟਾ [\'ਘੱਟ\'], ਡਾਟਾ [\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) ਡਾਟਾ [\'adx\'] =adx_indicator.adx () ਡਾਟਾ [\'ਡਿ _ ਪੋਸ\'] = adx_indicator.adx _ ਪੋਸ () ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\'] = adx_indicator.adx _ ਨੈਗ () #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋਡਾਟਾ [\'ਸਿਗਨਲ\'] = 0 ਡਾਟਾ [\'ਪੋਜੀਸ਼ਨ\'] = 0 i ਲਈ ਰੇਂਜ ਵਿੱਚ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ #ਸਿਗਨਲ ਖਰੀਦੋ ਜੇਕਰ ਡਾਟਾ [\'rsi\'] ਹੈ।ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇ ਡਾਟਾ [\'Di _ poss\']. iloc [i]> ਡਾਟਾ [\'Di _ neg\']. iloc [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. iloc [i] = 1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i-1] = =0: ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i] = 1 ਇਕੁਇਟੀ + = 1 #ਸਿਗਨਲ ਐਲੀਫ ਡਾਟਾ [\'rsi\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ take _ ਲਾਭ ਅਤੇਡਾਟਾ [\'ਡਿ _ ਪੋਸ\']. ਆਈਲੋਕ [i] <ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\']. ਆਈਲੋਕ [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. ਆਈਲੋਕ [i] =-1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i-1] = = 1: ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i] = 0 ਇਕੁਇਟੀ- = 1', ' [\'#what ਨੂੰ ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ \\n\\ਨਿਮਪੋਰਟ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. \\ਨਿਮਪੋਰਟ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ. ਦੇ ਰੂਪ ਵਿੱਚ, ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. \\ਨਿਮਪੋਰਟ ਟਾ ਦੇ ਰੂਪ ਵਿੱਚ, ਚੇਤਾਵਨੀਆਂ।\\ nwarnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") \\n\\nequity = 100000\\n\\ndef rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30,rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20, adx _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): \\n #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-\\n ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\\\'rsi\\\'] =ta.momentum.RSIIndicator (ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () \\n adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\\\'ਉੱਚ\'], ਡਾਟਾ [\\\'ਘੱਟ\'],ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\\\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) \\n ਡਾਟਾ [\\\'adx\\\'] = adx_indicator.adx () \\n ਡਾਟਾ [\\\'ti _ poss\\\'] = adx_indicator.adx _ poss () \\n ਡਾਟਾ [\\\'ti _ neg\\\'] =adx_indicator.adx_neg () \\n\\n #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋ \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\'] = 0\\n ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\'] = 0\\n ਵਿੱਚ i ਲਈਰੇਂਜ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ \\n #ਸਿਗਨਲ ਖਰੀਦੋ \\n ਜੇਕਰ ਡਾਟਾ [\\\'rsi\\\']. iloc [i] <rsi _ oversold ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇਡਾਟਾ [\\\'ਡਾਇਆ _ ਪੋਜ਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼ਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 1\\n ਇਕੁਇਟੀ + = 1\\n\\n #ਸਿਗਨਲ ਵੇਚੋ\\n ਐਲੀਫ ਡਾਟਾ [\\\'rsi\\\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]>ਐਡਐਕਸ _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ ਅਤੇ ਡੇਟਾ [\\\'ਡਿ _ ਪੋਸ\\\']. ਇਲੋਕ [i] <ਡੇਟਾ [\\\'ਡਿ _ ਨੈਗ\\\']. ਇਲੋਕ [i]: \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\']. ਇਲੋਕ [i] =-1 \\n ਜੇਕਰ ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\']. ਇਲੋਕ [i-1] = = 1: \\nਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 0\\n ਇਕੁਇਟੀ-= 1\\n\\n \', "ਕੁੱਝ ਖੇਤਰ ਹਨ ਜੋ ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨਃ \\n\\n1।ਸਿਰਫ ਆਖਰੀ \'rsi _ ਪੀਰੀਅਡ-1\' ਕਤਾਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਸੋਧਿਆ ਗਿਆ ਹੈ, ਜਿਸ ਨੂੰ ਸਿਰਫ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਕਤਾਰ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਘਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜੇ RSI ਮੁੱਲ ਨਹੀਂ ਹੈਕਤਾਰਾਂ ਵਿਚਕਾਰ ਮਹੱਤਵਪੂਰਨ ਤਬਦੀਲੀ. \\n2. \'ਜੇਕਰ\' ਬਿਆਨ ਜੋ ਇਹ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਕਤਾਰ ਲੂਪ ਦੀ ਪਹਿਲੀ ਕਤਾਰ ਹੈ, ਨੂੰ ਕਤਾਰ ਤੋਂ ਬਾਹਰ ਲਿਜਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਲਈ ਲੂਪ। \\n3. ਹਰੇਕ ਕਤਾਰ ਲਈ \'ਡੇਟਾ [\' ਸਥਿਤੀ \']\' ਅਤੇ \'ਡੇਟਾ [\' ਸੰਕੇਤ \']\' ਕਾਲਮਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਲਈ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਹੈ।ਵੱਡੇ ਡੇਟਾਸੇਟ। ਲੂਪ ਤੋਂ ਬਾਹਰ ਇਹਨਾਂ ਮੁੱਲਾਂ ਦੀ ਪੂਰਵ-ਗਣਨਾ ਕਰਨਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਉਦੋਂ ਹੀ ਅੱਪਡੇਟ ਕਰਨਾ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਸੰਕੇਤ ਜਾਂ ਸਥਿਤੀ ਹੋਵੇ।ਤਬਦੀਲੀਆਂ. \\n4. \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜੋ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਸਥਿਤੀ 0 ਤੋਂ 1 (ਜਾਂ ਇਸਦੇ ਉਲਟ) ਵਿੱਚ ਬਦਲ ਰਹੀ ਹੈ, ਨੂੰ ਇੱਕ ਸਿੰਗਲ \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਇਹ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਸਥਿਤੀ ਬਦਲ ਰਹੀ ਹੈ ਜਾਂ ਨਹੀਂ, ਜੋ ਤੁਲਨਾ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਏਗੀ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗੀ। \\n5. \'ਇਕੁਇਟੀ\' ਵੇਰੀਏਬਲ ਹੋ ਸਕਦਾ ਹੈਲੂਪ ਦੇ ਬਾਹਰ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਇਸ ਨੂੰ ਹਰ ਕਤਾਰ ਲਈ ਮੁਡ਼ ਗਿਣਤੀ ਤੋਂ ਬਚਾਇਆ ਜਾ ਸਕੇ। \\n6. ਕੋਡ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ \'mp.Process\' ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੈਰਲਲਾਈਜ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਈਮ। ਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਸ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵਿੱਚ ਗਣਨਾਵਾਂ ਅਤੇ ਤੁਲਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣਾ, ਬਾਹਰਲੇ ਮੁੱਲਾਂ ਦੀ ਪੂਰਵ-ਗਣਨਾ ਕਰਨਾ ਸ਼ਾਮਲ ਹੋ ਸਕਦਾ ਹੈ।ਲੂਪ ਦਾ, ਅਤੇ ਤੇਜ਼ੀ ਨਾਲ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ ਕੋਡ ਨੂੰ ਪੈਰਲਲਾਈਜ਼ ਕਰਨਾ।, \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਸਾਰੇ ਇੰਪੁੱਟ ਨਾਲ ਦੁਬਾਰਾ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਮੈਨੂੰ ਦਿੱਤਾ ਹੈ \',\' ਯਕੀਨਨ, ਇੱਥੇ ਇੱਕ ਦੁਬਾਰਾ ਕੰਮ ਕੀਤਾ ਗਿਆ ਹੈ।ਕੋਡ ਦਾ ਸੰਸਕਰਣ ਜਿਸ ਵਿੱਚ ਉਹਨਾਂ ਸੁਝਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਮੈਂ ਪਹਿਲਾਂ ਜ਼ਿਕਰ ਕੀਤਾ ਹੈਃ \\n "\'ਪਾਈਥਨ \\ਨਿੰਪੋਰਟ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. \\ਨਿੰਪੋਰਟ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ. ਦੇ ਰੂਪ ਵਿੱਚ, ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. ਦੇ ਰੂਪ ਵਿੱਚ\\nimport ta, ਚੇਤਾਵਨੀਆਂ\\nwarnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") \\n\\nequity = 100000\\n\\ndef rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14,rsi _ ਓਵਰਸੋਲਡ = 30, rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20, adx _ take _ ਪ੍ਰੋਫਿਟ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): \\n #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-\\n ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\\\'rsi\\\'] =ta.momentum.RSIIndicator (ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () \\n adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\\\'ਉੱਚ\'], ਡਾਟਾ [\\\'ਘੱਟ\'],ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\\\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) \\n ਡਾਟਾ [\\\'adx\\\'] = adx_indicator.adx () \\n ਡਾਟਾ [\\\'ti _ poss\\\'] = adx_indicator.adx _ poss () \\n ਡਾਟਾ [\\\'ti _ neg\\\'] =adx_indicator.adx_neg () \\n\\n #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋ \\n ਸੰਕੇਤ = ਡਾਟਾ [\\\'rsi\\\']. ਸ਼ਿਫਟ (1) <rsi _ ਓਵਰਸੋਲਡ * np.ones (rsi _ ਪੀਰੀਅਡ) + (1 -rsi _ ਓਵਰਸੋਲਡ) * (ਡਾਟਾ [\\\'adx\\\']> adx _ ਰੀਲੋਡ) * np.ones (adx _ ਪੀਰੀਅਡ) \\n ਸਥਿਤੀਆਂ = np.zeros (ਲੇਨ (ਡਾਟਾ)) \\n ਸੀਮਾ ਵਿੱਚ i ਲਈ (adx _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): \\n ਜੇਕਰਸੰਕੇਤ [i-1] ਅਤੇ ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਪੋਸ\'] [i]> ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਨੈਗ\'] [i]: \\n ਸਥਿਤੀਆਂ [i] = 1\\n ਐਲੀਫ ਸੰਕੇਤ [i-1] ਅਤੇ ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਨੈਗ\'] [i]> ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਪੋਸ\'] [i]: \\nਸਥਿਤੀਆਂ [i] =-1 \\n ਐਲੀਫ ਸੰਕੇਤ [i-1] ਅਤੇ ਡੇਟਾ [\\\'adx\\\'] [i]> adx _ take _ ਪ੍ਰੋਫਿਟਃ \\n ਸਥਿਤੀਆਂ \',\' ਜਾਰੀ ਰੱਖੋ ਜਿੱਥੇ ਤੁਸੀਂ ਰੁਕਿਆ \', ਸਥਿਤੀਆਂ [i] =- 1 \\nelse: \\nਪੋਜੀਸ਼ਨਸ [i] = 0\\n "\'\\n #ਇਕੁਇਟੀ ਕਰਵ ਦੀ ਗਣਨਾ ਕਰੋ \\nequity _ وکر = [ਇਕੁਇਟੀ] \\n ਫਾਰ i ਰੇਂਜ ਵਿੱਚ (ਲੇਨ (ਡਾਟਾ)-1): \\nif ਸਥਿਤੀਆਂ [i] = = =1:\\nequity_curve.append (ਇਕੁਇਟੀ-1) \\nelif ਸਥਿਤੀਆਂ [i] = =-1:\\nequity_curve.append (ਇਕੁਇਟੀ + 1) \\nelse:\\nequity_curve.append (ਇਕੁਇਟੀ) \\n\\nਇਕੁਇਟੀ _ ਕਰਵ \\n "\'\\n\\n"\' css\\n \'ਕੋਡ ਦੇ ਇਸ ਸੰਸਕਰਣ ਵਿੱਚ, ਮੈਂ ਹੇਠ ਲਿਖੀਆਂ ਤਬਦੀਲੀਆਂ ਕੀਤੀਆਂ ਹਨਃ \\n\\n-RSI ਅਤੇ ADX ਗਣਨਾਵਾਂ ਨੂੰ ਬਾਹਰ ਲਿਜਾਇਆ ਗਿਆ ਹੈ।ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨ ਲਈ ਲੂਪ ਦੀ ਗਿਣਤੀ। \\n-\'ਸਿਗਨਲ\' ਵੇਰੀਏਬਲ ਦੀ ਗਿਣਤੀ ਹੁਣ ਲੂਪ ਦੇ ਬਾਹਰ \'ਸ਼ਿਫਟ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਜੋ ਇਸ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਇਆ ਜਾ ਸਕੇ।ਹਰੇਕ ਕਤਾਰ ਲਈ ਗਣਨਾ। \\n-\'ਸਥਿਤੀਆਂ\' ਵੇਰੀਏਬਲ ਦੀ ਗਣਨਾ ਹੁਣ ਲੂਪ ਦੇ ਬਾਹਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਸਿਰਫ ਉਦੋਂ ਅਪਡੇਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਸੰਕੇਤ ਜਾਂ ਸਥਿਤੀ ਬਦਲਦੀ ਹੈ। \\n -\'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜੋ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਕਤਾਰ ਲੂਪ ਦੀ ਪਹਿਲੀ ਕਤਾਰ ਹੈ, ਨੂੰ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਲਈ ਲੂਪ ਤੋਂ ਬਾਹਰ ਲਿਜਾਇਆ ਗਿਆ ਹੈ। \\n -\'ਇਕੁਇਟੀ\' ਵੇਰੀਏਬਲ ਦੀ ਗਣਨਾ ਹੁਣ ਲੂਪ ਦੇ ਬਾਹਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਜੋ ਇਸ ਨੂੰ ਹਰ ਕਤਾਰ ਲਈ ਮੁਡ਼ ਗਿਣਤੀ ਤੋਂ ਬਚਾਇਆ ਜਾ ਸਕੇ। \\n-ਲੂਪ ਨੂੰ ਸਿਰਫ਼ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਸਰਲ ਬਣਾਇਆ ਗਿਆ ਹੈਸਭ ਤੋਂ ਤਾਜ਼ਾ ਕਤਾਰ ਅਤੇ \'ਸਥਿਤੀਆਂ\' ਵੇਰੀਏਬਲ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ। \\n-\'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜੋ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਸਥਿਤੀ 0 ਤੋਂ 1 (ਜਾਂ ਇਸਦੇ ਉਲਟ) ਵਿੱਚ ਬਦਲ ਰਹੀ ਹੈਇੱਕ ਸਿੰਗਲ \'ਜੇ\' ਸਟੇਟਮੈਂਟ ਨਾਲ ਬਦਲਿਆ ਗਿਆ ਹੈ ਜੋ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਸਥਿਤੀ ਬਦਲ ਰਹੀ ਹੈ ਜਾਂ ਨਹੀਂ, ਜੋ ਤੁਲਨਾ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਂਦੀ ਹੈ ਅਤੇ ਸੁਧਾਰ ਕਰਦੀ ਹੈਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਹਨਾਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਗਣਨਾਵਾਂ ਅਤੇ ਤੁਲਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾ ਕੇ ਕੋਡ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ,ਲੂਪ ਦੇ ਬਾਹਰ ਮੁੱਲਾਂ ਦੀ ਪੂਰਵ-ਗਣਨਾ ਕਰਨਾ, ਅਤੇ ਲੂਪ ਨੂੰ ਸਰਲ ਬਣਾਉਣਾ। \\n \'\', \'ਇਸ ਵੇਲੇ ਤੁਹਾਡਾ ਮਾਡਲ ਕਿਸ ਸਹੀ ਹਾਰਡਵੇਅਰ ਉੱਤੇ ਚੱਲ ਰਿਹਾ ਹੈ?\' ', '#what ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. ਆਯਾਤ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ., ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. ਆਯਾਤ ਟਾ, ਚੇਤਾਵਨੀਆਂ warnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") ਦੇ ਰੂਪ ਵਿੱਚ ਆਯਾਤ ਕਰੋ।ਇਕੁਇਟੀ = 100000 ਡਿਫ rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30, rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20,adx _ take _ ਲਾਭ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\'rsi\'] = ta.momentum.RSIIndicator (ਡੇਟਾ [\'ਬੰਦ ਕਰੋ\'],ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\'ਉੱਚ\'], ਡਾਟਾ [\'ਘੱਟ\'], ਡਾਟਾ [\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) ਡਾਟਾ [\'adx\'] =adx_indicator.adx () ਡਾਟਾ [\'ਡਿ _ ਪੋਸ\'] = adx_indicator.adx _ ਪੋਸ () ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\'] = adx_indicator.adx _ ਨੈਗ () #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋਡਾਟਾ [\'ਸਿਗਨਲ\'] = 0 ਡਾਟਾ [\'ਪੋਜੀਸ਼ਨ\'] = 0 i ਲਈ ਰੇਂਜ ਵਿੱਚ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ #ਸਿਗਨਲ ਖਰੀਦੋ ਜੇਕਰ ਡਾਟਾ [\'rsi\'] ਹੈ।ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇ ਡਾਟਾ [\'Di _ poss\']. iloc [i]> ਡਾਟਾ [\'Di _ neg\']. iloc [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. iloc [i] = 1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i-1] = =0: ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i] = 1 ਇਕੁਇਟੀ + = 1 #ਸਿਗਨਲ ਐਲੀਫ ਡਾਟਾ [\'rsi\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ take _ ਲਾਭ ਅਤੇਡਾਟਾ [\'ਡਿ _ ਪੋਸ\']. ਆਈਲੋਕ [i] <ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\']. ਆਈਲੋਕ [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. ਆਈਲੋਕ [i] =-1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i-1] = = 1: ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i] = 0 ਇਕੁਇਟੀ- = 1', ' [\'#what ਨੂੰ ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ \\n\\ਨਿਮਪੋਰਟ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. \\ਨਿਮਪੋਰਟ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ. ਦੇ ਰੂਪ ਵਿੱਚ, ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. \\ਨਿਮਪੋਰਟ ਟਾ ਦੇ ਰੂਪ ਵਿੱਚ, ਚੇਤਾਵਨੀਆਂ।\\ nwarnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") \\n\\nequity = 100000\\n\\ndef rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30,rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20, adx _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): \\n #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-\\n ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\\\'rsi\\\'] =ta.momentum.RSIIndicator (ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () \\n adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\\\'ਉੱਚ\'], ਡਾਟਾ [\\\'ਘੱਟ\'],ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\\\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) \\n ਡਾਟਾ [\\\'adx\\\'] = adx_indicator.adx () \\n ਡਾਟਾ [\\\'ti _ poss\\\'] = adx_indicator.adx _ poss () \\n ਡਾਟਾ [\\\'ti _ neg\\\'] =adx_indicator.adx_neg () \\n\\n #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋ \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\'] = 0\\n ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\'] = 0\\n ਵਿੱਚ i ਲਈਰੇਂਜ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ \\n #ਸਿਗਨਲ ਖਰੀਦੋ \\n ਜੇਕਰ ਡਾਟਾ [\\\'rsi\\\']. iloc [i] <rsi _ oversold ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇਡਾਟਾ [\\\'ਡਾਇਆ _ ਪੋਜ਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼਼ਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 1\\n ਇਕੁਇਟੀ + = 1\\n\\n #ਸਿਗਨਲ ਵੇਚੋ\\n ਐਲੀਫ ਡਾਟਾ [\\\'rsi\\\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\\\'adx\\\']. iloc [i]>ਐਡਐਕਸ _ ਟੇਕ _ ਪ੍ਰੋਫਿਟ ਅਤੇ ਡੇਟਾ [\\\'ਡਿ _ ਪੋਸ\\\']. ਇਲੋਕ [i] <ਡੇਟਾ [\\\'ਡਿ _ ਨੈਗ\\\']. ਇਲੋਕ [i]: \\n ਡੇਟਾ [\\\'ਸਿਗਨਲ\\\']. ਇਲੋਕ [i] =-1 \\n ਜੇਕਰ ਡੇਟਾ [\\\'ਸਥਿਤੀ\\\']. ਇਲੋਕ [i-1] = = 1: \\nਡਾਟਾ [\\\'ਸਥਿਤੀ\\\']. iloc [i] = 0\\n ਇਕੁਇਟੀ-= 1\\n\\n \', "ਕੁੱਝ ਖੇਤਰ ਹਨ ਜੋ ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨਃ \\n\\n1।ਸਿਰਫ ਆਖਰੀ \'rsi _ ਪੀਰੀਅਡ-1\' ਕਤਾਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਸੋਧਿਆ ਗਿਆ ਹੈ, ਜਿਸ ਨੂੰ ਸਿਰਫ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਕਤਾਰ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਘਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜੇ RSI ਮੁੱਲ ਨਹੀਂ ਹੈਕਤਾਰਾਂ ਵਿਚਕਾਰ ਮਹੱਤਵਪੂਰਨ ਤਬਦੀਲੀ. \\n2. \'ਜੇਕਰ\' ਬਿਆਨ ਜੋ ਇਹ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਕਤਾਰ ਲੂਪ ਦੀ ਪਹਿਲੀ ਕਤਾਰ ਹੈ, ਨੂੰ ਕਤਾਰ ਤੋਂ ਬਾਹਰ ਲਿਜਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਲਈ ਲੂਪ। \\n3. ਹਰੇਕ ਕਤਾਰ ਲਈ \'ਡੇਟਾ [\' ਸਥਿਤੀ \']\' ਅਤੇ \'ਡੇਟਾ [\' ਸੰਕੇਤ \']\' ਕਾਲਮਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਲਈ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਹੈ।ਵੱਡੇ ਡੇਟਾਸੇਟ। ਲੂਪ ਤੋਂ ਬਾਹਰ ਇਹਨਾਂ ਮੁੱਲਾਂ ਦੀ ਪੂਰਵ-ਗਣਨਾ ਕਰਨਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਉਦੋਂ ਹੀ ਅੱਪਡੇਟ ਕਰਨਾ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਸੰਕੇਤ ਜਾਂ ਸਥਿਤੀ ਹੋਵੇ।ਤਬਦੀਲੀਆਂ. \\n4. \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜੋ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਸਥਿਤੀ 0 ਤੋਂ 1 (ਜਾਂ ਇਸਦੇ ਉਲਟ) ਵਿੱਚ ਬਦਲ ਰਹੀ ਹੈ, ਨੂੰ ਇੱਕ ਸਿੰਗਲ \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਇਹ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਸਥਿਤੀ ਬਦਲ ਰਹੀ ਹੈ ਜਾਂ ਨਹੀਂ, ਜੋ ਤੁਲਨਾ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਏਗੀ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗੀ। \\n5. \'ਇਕੁਇਟੀ\' ਵੇਰੀਏਬਲ ਹੋ ਸਕਦਾ ਹੈਲੂਪ ਦੇ ਬਾਹਰ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਇਸ ਨੂੰ ਹਰ ਕਤਾਰ ਲਈ ਮੁਡ਼ ਗਿਣਤੀ ਤੋਂ ਬਚਾਇਆ ਜਾ ਸਕੇ। \\n6. ਕੋਡ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ \'mp.Process\' ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੈਰਲਲਾਈਜ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਈਮ। ਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਸ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵਿੱਚ ਗਣਨਾਵਾਂ ਅਤੇ ਤੁਲਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣਾ, ਬਾਹਰਲੇ ਮੁੱਲਾਂ ਦੀ ਪੂਰਵ-ਗਣਨਾ ਕਰਨਾ ਸ਼ਾਮਲ ਹੋ ਸਕਦਾ ਹੈ।ਲੂਪ ਦਾ, ਅਤੇ ਤੇਜ਼ੀ ਨਾਲ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ ਕੋਡ ਨੂੰ ਪੈਰਲਲਾਈਜ਼ ਕਰਨਾ।, \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਸਾਰੇ ਇੰਪੁੱਟ ਨਾਲ ਦੁਬਾਰਾ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਮੈਨੂੰ ਦਿੱਤਾ ਹੈ \',\' ਯਕੀਨਨ, ਇੱਥੇ ਇੱਕ ਦੁਬਾਰਾ ਕੰਮ ਕੀਤਾ ਗਿਆ ਹੈ।ਕੋਡ ਦਾ ਸੰਸਕਰਣ ਜਿਸ ਵਿੱਚ ਉਹਨਾਂ ਸੁਝਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਮੈਂ ਪਹਿਲਾਂ ਜ਼ਿਕਰ ਕੀਤਾ ਹੈਃ \\n "\'ਪਾਈਥਨ \\ਨਿੰਪੋਰਟ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. \\ਨਿੰਪੋਰਟ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ. ਦੇ ਰੂਪ ਵਿੱਚ, ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. ਦੇ ਰੂਪ ਵਿੱਚ\\nimport ta, ਚੇਤਾਵਨੀਆਂ\\nwarnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") \\n\\nequity = 100000\\n\\ndef rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14,rsi _ ਓਵਰਸੋਲਡ = 30, rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20, adx _ take _ ਪ੍ਰੋਫਿਟ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): \\n #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-\\n ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\\\'rsi\\\'] =ta.momentum.RSIIndicator (ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () \\n adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\\\'ਉੱਚ\'], ਡਾਟਾ [\\\'ਘੱਟ\'],ਡਾਟਾ [\\\'ਬੰਦ ਕਰੋ\\\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) \\n ਡਾਟਾ [\\\'adx\\\'] = adx_indicator.adx () \\n ਡਾਟਾ [\\\'ti _ poss\\\'] = adx_indicator.adx _ poss () \\n ਡਾਟਾ [\\\'ti _ neg\\\'] =adx_indicator.adx_neg () \\n\\n #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋ \\n ਸੰਕੇਤ = ਡਾਟਾ [\\\'rsi\\\']. ਸ਼ਿਫਟ (1) <rsi _ ਓਵਰਸੋਲਡ * np.ones (rsi _ ਪੀਰੀਅਡ) + (1 -rsi _ ਓਵਰਸੋਲਡ) * (ਡਾਟਾ [\\\'adx\\\']> adx _ ਰੀਲੋਡ) * np.ones (adx _ ਪੀਰੀਅਡ) \\n ਸਥਿਤੀਆਂ = np.zeros (ਲੇਨ (ਡਾਟਾ)) \\n ਸੀਮਾ ਵਿੱਚ i ਲਈ (adx _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): \\n ਜੇਕਰਸੰਕੇਤ [i-1] ਅਤੇ ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਪੋਸ\'] [i]> ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਨੈਗ\'] [i]: \\n ਸਥਿਤੀਆਂ [i] = 1\\n ਐਲੀਫ ਸੰਕੇਤ [i-1] ਅਤੇ ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਨੈਗ\'] [i]> ਅੰਕਡ਼ੇ [\\\'ਡਿ _ ਪੋਸ\'] [i]: \\nਸਥਿਤੀਆਂ [i] =-1 \\n ਐਲੀਫ ਸੰਕੇਤ [i-1] ਅਤੇ ਡੇਟਾ [\\\'adx\\\'] [i]> adx _ take _ ਪ੍ਰੋਫਿਟਃ \\n ਸਥਿਤੀਆਂ \',\' ਜਾਰੀ ਰੱਖੋ ਜਿੱਥੇ ਤੁਸੀਂ ਰੁਕਿਆ \', ਸਥਿਤੀਆਂ [i] =- 1 \\nelse: \\nਪੋਜੀਸ਼ਨਸ [i] = 0\\n "\'\\n #ਇਕੁਇਟੀ ਕਰਵ ਦੀ ਗਣਨਾ ਕਰੋ \\nequity _ وکر = [ਇਕੁਇਟੀ] \\n ਫਾਰ i ਰੇਂਜ ਵਿੱਚ (ਲੇਨ (ਡਾਟਾ)-1): \\nif ਸਥਿਤੀਆਂ [i] = = =1:\\nequity_curve.append (ਇਕੁਇਟੀ-1) \\nelif ਸਥਿਤੀਆਂ [i] = =-1:\\nequity_curve.append (ਇਕੁਇਟੀ + 1) \\nelse:\\nequity_curve.append (ਇਕੁਇਟੀ) \\n\\nਇਕੁਇਟੀ _ ਕਰਵ \\n "\'\\n\\n"\' css\\n \'ਕੋਡ ਦੇ ਇਸ ਸੰਸਕਰਣ ਵਿੱਚ, ਮੈਂ ਹੇਠ ਲਿਖੀਆਂ ਤਬਦੀਲੀਆਂ ਕੀਤੀਆਂ ਹਨਃ \\n\\n-RSI ਅਤੇ ADX ਗਣਨਾਵਾਂ ਨੂੰ ਬਾਹਰ ਲਿਜਾਇਆ ਗਿਆ ਹੈ।ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨ ਲਈ ਲੂਪ ਦੀ ਗਿਣਤੀ। \\n-\'ਸਿਗਨਲ\' ਵੇਰੀਏਬਲ ਦੀ ਗਿਣਤੀ ਹੁਣ ਲੂਪ ਦੇ ਬਾਹਰ \'ਸ਼ਿਫਟ\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਜੋ ਇਸ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਇਆ ਜਾ ਸਕੇ।ਹਰੇਕ ਕਤਾਰ ਲਈ ਗਣਨਾ। \\n-\'ਸਥਿਤੀਆਂ\' ਵੇਰੀਏਬਲ ਦੀ ਗਣਨਾ ਹੁਣ ਲੂਪ ਦੇ ਬਾਹਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਸਿਰਫ ਉਦੋਂ ਅਪਡੇਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਸੰਕੇਤ ਜਾਂ ਸਥਿਤੀ ਬਦਲਦੀ ਹੈ। \\n -\'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜੋ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕੀ ਮੌਜੂਦਾ ਕਤਾਰ ਲੂਪ ਦੀ ਪਹਿਲੀ ਕਤਾਰ ਹੈ, ਨੂੰ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਲਈ ਲੂਪ ਤੋਂ ਬਾਹਰ ਲਿਜਾਇਆ ਗਿਆ ਹੈ। \\n -\'ਇਕੁਇਟੀ\' ਵੇਰੀਏਬਲ ਦੀ ਗਣਨਾ ਹੁਣ ਲੂਪ ਦੇ ਬਾਹਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਜੋ ਇਸ ਨੂੰ ਹਰ ਕਤਾਰ ਲਈ ਮੁਡ਼ ਗਿਣਤੀ ਤੋਂ ਬਚਾਇਆ ਜਾ ਸਕੇ। \\n-ਲੂਪ ਨੂੰ ਸਿਰਫ਼ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਸਰਲ ਬਣਾਇਆ ਗਿਆ ਹੈਸਭ ਤੋਂ ਤਾਜ਼ਾ ਕਤਾਰ ਅਤੇ \'ਸਥਿਤੀਆਂ\' ਵੇਰੀਏਬਲ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ। \\n-\'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜੋ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਸਥਿਤੀ 0 ਤੋਂ 1 (ਜਾਂ ਇਸਦੇ ਉਲਟ) ਵਿੱਚ ਬਦਲ ਰਹੀ ਹੈਇੱਕ ਸਿੰਗਲ \'ਜੇ\' ਸਟੇਟਮੈਂਟ ਨਾਲ ਬਦਲਿਆ ਗਿਆ ਹੈ ਜੋ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਸਥਿਤੀ ਬਦਲ ਰਹੀ ਹੈ ਜਾਂ ਨਹੀਂ, ਜੋ ਤੁਲਨਾ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਂਦੀ ਹੈ ਅਤੇ ਸੁਧਾਰ ਕਰਦੀ ਹੈਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਹਨਾਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਗਣਨਾਵਾਂ ਅਤੇ ਤੁਲਨਾਵਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾ ਕੇ ਕੋਡ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ,ਲੂਪ ਤੋਂ ਬਾਹਰ ਮੁੱਲਾਂ ਦੀ ਪ੍ਰੀ-ਗਣਨਾ ਕਰਨਾ, ਅਤੇ ਲੂਪ ਨੂੰ ਸਰਲ ਬਣਾਉਣਾ। \\n "\',\' ਤੁਹਾਡਾ ਮਾਡਲ ਇਸ ਵੇਲੇ ਕਿਸ ਸਹੀ ਹਾਰਡਵੇਅਰ ਉੱਤੇ ਚੱਲ ਰਿਹਾ ਹੈ? \',\' ਕਿਸ ਉੱਤੇ?ਸਹੀ ਹਾਰਡਵੇਅਰ ਕੀ ਤੁਹਾਡਾ ਮਾਡਲ ਇਸ ਵੇਲੇ ਚੱਲ ਰਿਹਾ ਹੈ? ', '#what ਇਸ ਕੋਡ ਵਿੱਚ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਐੱਮ. ਪੀ. ਆਯਾਤ ਪਾਂਡਾ ਨੂੰ ਪੀ. ਡੀ., ਨੰਪੀ ਨੂੰ ਐੱਨ. ਪੀ. ਆਯਾਤ ਟਾ, ਚੇਤਾਵਨੀਆਂ warnings.filterwarnings ("ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰੋ") ਦੇ ਰੂਪ ਵਿੱਚ ਆਯਾਤ ਕਰੋ।ਇਕੁਇਟੀ = 100000 ਡਿਫ rsi _ ਬੁਲ _ ਬੇਅਰ _ ਐਡੈਕਸ _ ਰਣਨੀਤੀ (ਡਾਟਾ, rsi _ ਪੀਰੀਅਡ = 14, adx _ ਪੀਰੀਅਡ = 14, rsi _ ਓਵਰਸੋਲਡ = 30, rsi _ ਓਵਰਬਾਊਟ = 70, adx _ ਰੀਲੋਡ = 20,adx _ take _ ਲਾਭ = 50, ਇਕੁਇਟੀ = ਇਕੁਇਟੀ): #ਆਰਐਸਆਈ, ਏਡੀਐਕਸ, ਅਤੇ ਡੀਆਈ + ਅਤੇ ਡੀਆਈ-ਡੇਟਾ ਦੀ ਗਣਨਾ ਕਰੋ [\'rsi\'] = ta.momentum.RSIIndicator (ਡੇਟਾ [\'ਬੰਦ ਕਰੋ\'],ਵਿੰਡੋ = rsi _ ਪੀਰੀਅਡ). rsi () adx _ indicator = ta.trend.ADXIndicator (ਡਾਟਾ [\'ਉੱਚ\'], ਡਾਟਾ [\'ਘੱਟ\'], ਡਾਟਾ [\'ਬੰਦ ਕਰੋ\'], ਵਿੰਡੋ = adx _ ਪੀਰੀਅਡ) ਡਾਟਾ [\'adx\'] =adx_indicator.adx () ਡਾਟਾ [\'ਡਿ _ ਪੋਸ\'] = adx_indicator.adx _ ਪੋਸ () ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\'] = adx_indicator.adx _ ਨੈਗ () #ਸੰਕੇਤਾਂ ਅਤੇ ਸਥਿਤੀ ਕਾਲਮਾਂ ਨੂੰ ਅਰੰਭ ਕਰੋਡਾਟਾ [\'ਸਿਗਨਲ\'] = 0 ਡਾਟਾ [\'ਪੋਜੀਸ਼ਨ\'] = 0 i ਲਈ ਰੇਂਜ ਵਿੱਚ (rsi _ ਪੀਰੀਅਡ-1, ਲੇਨ (ਡਾਟਾ)): #ਸੋਧੀ ਹੋਈ ਰੇਂਜ #ਸਿਗਨਲ ਖਰੀਦੋ ਜੇਕਰ ਡਾਟਾ [\'rsi\'] ਹੈ।ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ ਰੀਲੋਡ ਅਤੇ ਡਾਟਾ [\'Di _ poss\']. iloc [i]> ਡਾਟਾ [\'Di _ neg\']. iloc [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. iloc [i] = 1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i-1] = =0: ਡਾਟਾ [\'ਸਥਿਤੀ\']. iloc [i] = 1 ਇਕੁਇਟੀ + = 1 #ਸਿਗਨਲ ਐਲੀਫ ਡਾਟਾ [\'rsi\']. iloc [i]> rsi _ ਓਵਰਬਾਊਟ ਅਤੇ ਡਾਟਾ [\'adx\']. iloc [i]> adx _ take _ ਲਾਭ ਅਤੇਡਾਟਾ [\'ਡਿ _ ਪੋਸ\']. ਆਈਲੋਕ [i] <ਡਾਟਾ [\'ਡਿ _ ਨੈਗ\']. ਆਈਲੋਕ [i]: ਡਾਟਾ [\'ਸਿਗਨਲ\']. ਆਈਲੋਕ [i] =-1 ਜੇਕਰ ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i-1] = = 1: ਡਾਟਾ [\'ਸਥਿਤੀ\']. ਆਈਲੋਕ [i] = 0 ਇਕੁਇਟੀ- = 1 \n ']