diff --git a/Code/Mantid/API/inc/MantidAPI/TripleIterator.h b/Code/Mantid/API/inc/MantidAPI/TripleIterator.h
index fad1ea02fbf0120344aead937c9ce6539a1b1d2d..294eec6e772879b604559550d9f99faf7004fd48 100644
--- a/Code/Mantid/API/inc/MantidAPI/TripleIterator.h
+++ b/Code/Mantid/API/inc/MantidAPI/TripleIterator.h
@@ -45,6 +45,8 @@ private:
   _Container *m_workspace;
   /// pointer to a TripleRef of doubles
   TripleRef<double> m_CPoint;
+  ///The number of times this iterator should loop before ending
+  int m_loopCount;
   /// internal index of location within the workspace
   int m_index;
   ///Internal cache of the workspace size
@@ -79,6 +81,7 @@ public:
   
   triple_iterator();
   triple_iterator(_Container&);
+  triple_iterator(_Container&, int loopCount);
   triple_iterator(const triple_iterator&);
 
   reference operator*() { return m_CPoint; }   ///< Base Accessor
diff --git a/Code/Mantid/API/inc/MantidAPI/TripleIteratorCode.h b/Code/Mantid/API/inc/MantidAPI/TripleIteratorCode.h
index e893a8657192a1cdefc3c2ba8c63fbac9228939a..042220f498babe59dcd810c70d2bfe66b31872a3 100644
--- a/Code/Mantid/API/inc/MantidAPI/TripleIteratorCode.h
+++ b/Code/Mantid/API/inc/MantidAPI/TripleIteratorCode.h
@@ -13,7 +13,7 @@ namespace Mantid
     */
     template<typename _Iterator, typename _Container>
     triple_iterator<_Iterator, _Container>::triple_iterator() :
-      m_workspace(0),m_CPoint(),m_index(0),m_wsSize(0),m_blocksize(0),m_blockMin(-1),m_blockMax(-1)
+      m_workspace(0),m_CPoint(),m_index(0),m_wsSize(0),m_blocksize(0),m_blockMin(-1),m_blockMax(-1),m_loopCount(1)
     {}
 
     /*!
@@ -23,10 +23,25 @@ namespace Mantid
     template<typename _Iterator, typename _Container>
     triple_iterator<_Iterator, _Container>::triple_iterator(_Container& WA) :
       m_workspace(&WA),m_CPoint(),m_index(0),
-      m_wsSize(m_workspace->size()),m_blocksize(m_workspace->blocksize()),m_blockMin(-1),m_blockMax(-1)
+      m_wsSize(m_workspace->size()),m_blocksize(m_workspace->blocksize()),m_blockMin(-1),m_blockMax(-1),m_loopCount(1)
     {
       validateIndex();
     }
+
+    /*!
+    Multiple loop workspace based constructor
+    \param WA :: Workspace to take pointer
+    \param loopCount :: The number of time this iterator should loop over the same data before stopping.
+    */
+    template<typename _Iterator, typename _Container>
+    triple_iterator<_Iterator, _Container>::triple_iterator(_Container& WA, int loopCount) :
+      m_workspace(&WA),m_CPoint(),m_index(0),
+      m_wsSize(m_workspace->size()),m_blocksize(m_workspace->blocksize()),m_blockMin(-1),m_blockMax(-1),m_loopCount(loopCount)
+    {
+      //pretend that the container is long than it is by multiplying its size by the loopcount
+      m_wsSize *= m_loopCount;
+      validateIndex();
+    }
     
     /*!
     Copy constructor
@@ -36,7 +51,7 @@ namespace Mantid
     triple_iterator<_Iterator, _Container>::triple_iterator(const triple_iterator<_Iterator, _Container>& A) :
       m_workspace(A.m_workspace),m_CPoint(),m_index(A.m_index),m_wsSize(A.m_wsSize),
       m_blocksize(A.m_blocksize),m_blockMin(A.m_blockMin),m_blockMax(A.m_blockMax),
-      it_dataX(A.it_dataX),it_dataY(A.it_dataY),it_dataE(A.it_dataE)
+      it_dataX(A.it_dataX),it_dataY(A.it_dataY),it_dataE(A.it_dataE),m_loopCount(A.m_loopCount)
     {
       validateIndex();
     }
@@ -64,6 +79,13 @@ namespace Mantid
           m_blockMin = m_index - (m_index % m_blocksize);
           m_blockMax = m_blockMin + m_blocksize -1;
 
+          //make sure you get the right block if you are looping multiple times
+          if (m_loopCount != 1)
+          {
+            int realWsSize = m_wsSize/m_loopCount;
+            m_dataBlockIndex = (m_index % realWsSize)/m_blocksize;
+          }
+
           it_dataX = m_workspace->dataX(m_dataBlockIndex).begin();
           it_dataY = m_workspace->dataY(m_dataBlockIndex).begin();
           it_dataE = m_workspace->dataE(m_dataBlockIndex).begin();
diff --git a/Code/Mantid/Algorithms/inc/MantidAlgorithms/BinaryOpHelper.h b/Code/Mantid/Algorithms/inc/MantidAlgorithms/BinaryOpHelper.h
index 3d36166b180547c8d1990e378dce16ee555d92f9..66d355a48eb9ad312480b5c976b7d7d80f0ba954 100644
--- a/Code/Mantid/Algorithms/inc/MantidAlgorithms/BinaryOpHelper.h
+++ b/Code/Mantid/Algorithms/inc/MantidAlgorithms/BinaryOpHelper.h
@@ -53,6 +53,7 @@ public:
 	
   const bool checkSizeCompatability(const API::Workspace_sptr ws1,const API::Workspace_sptr ws2) const;
   const bool checkXarrayCompatability(const API::Workspace_sptr ws1, const API::Workspace_sptr ws2) const;
+  const int getRelativeLoopCount(const API::Workspace_sptr ws1, const API::Workspace_sptr ws2) const;
   API::Workspace_sptr createOutputWorkspace(const API::Workspace_sptr ws1, const API::Workspace_sptr ws2) const;
 
 private:
diff --git a/Code/Mantid/Algorithms/src/BinaryOpHelper.cpp b/Code/Mantid/Algorithms/src/BinaryOpHelper.cpp
index 20d416cd775225b3fb36d907c554cc9f244dc459..16ad693d6b7e72e04e4e467b6df2fb335d557f7a 100644
--- a/Code/Mantid/Algorithms/src/BinaryOpHelper.cpp
+++ b/Code/Mantid/Algorithms/src/BinaryOpHelper.cpp
@@ -68,6 +68,20 @@ namespace Mantid
         return false;
     }
 
+    /** Gets the number of time an iterator over the first workspace would have to loop to perform a full iteration of the second workspace
+    * @param ws1 the first workspace to compare
+    * @param ws2 the second workspace to compare
+    * @returns Integer division of ws2.size()/ws1.size() with a minimum of 1
+    */
+    const int BinaryOpHelper::getRelativeLoopCount(const API::Workspace_sptr ws1, const API::Workspace_sptr ws2) const
+    {
+      int ws1Size = ws1->size();
+      if (ws1Size == 0) return 1;
+      int retVal = ws2->size()/ws1Size;
+      return (retVal == 0)?1:retVal;
+    }
+  
+
 
     /** Creates a suitable output workspace for a binary operatiion based on the two input workspaces
     * @param ws1 the first workspace to compare
diff --git a/Code/Mantid/Algorithms/src/Divide.cpp b/Code/Mantid/Algorithms/src/Divide.cpp
index 0bb88cd8505746a45d7e86a5770ee9488d0aab8c..8670d1671edd777a49261c0208448ba5de74ab31 100644
--- a/Code/Mantid/Algorithms/src/Divide.cpp
+++ b/Code/Mantid/Algorithms/src/Divide.cpp
@@ -59,8 +59,8 @@ namespace Mantid
       Workspace_sptr out_work = boHelper.createOutputWorkspace(in_work1,in_work2);
 
       Workspace::iterator ti_out(*out_work);
-      Workspace::const_iterator ti_in1(*in_work1);
-      Workspace::const_iterator ti_in2(*in_work2);
+      Workspace::const_iterator ti_in1(*in_work1,boHelper.getRelativeLoopCount(in_work1,in_work2));
+      Workspace::const_iterator ti_in2(*in_work2,boHelper.getRelativeLoopCount(in_work2,in_work1));
       std::transform(ti_in1.begin(),ti_in1.end(),ti_in2.begin(),ti_out.begin(),Divide_fn());
 
       // Assign it to the output workspace property
diff --git a/Code/Mantid/Algorithms/src/Minus.cpp b/Code/Mantid/Algorithms/src/Minus.cpp
index ccb377656a57896c0b950ad09abb09fc8f5fcbc8..2c59c6a17ce09fc45d78cca49b65b41bbbddef13 100644
--- a/Code/Mantid/Algorithms/src/Minus.cpp
+++ b/Code/Mantid/Algorithms/src/Minus.cpp
@@ -59,8 +59,8 @@ namespace Mantid
       Workspace_sptr out_work = boHelper.createOutputWorkspace(in_work1,in_work2);
 
       Workspace::iterator ti_out(*out_work);
-      Workspace::const_iterator ti_in1(*in_work1);
-      Workspace::const_iterator ti_in2(*in_work2);
+      Workspace::const_iterator ti_in1(*in_work1,boHelper.getRelativeLoopCount(in_work1,in_work2));
+      Workspace::const_iterator ti_in2(*in_work2,boHelper.getRelativeLoopCount(in_work2,in_work1));
       std::transform(ti_in1.begin(),ti_in1.end(),ti_in2.begin(),ti_out.begin(),Minus_fn());
 
       // Assign it to the output workspace property
diff --git a/Code/Mantid/Algorithms/src/Multiply.cpp b/Code/Mantid/Algorithms/src/Multiply.cpp
index a6fd9ed046c3d6b689b08163b91ab336be03b892..ec558322fa7bd246df60631fb417bbbaaf2c3f4c 100644
--- a/Code/Mantid/Algorithms/src/Multiply.cpp
+++ b/Code/Mantid/Algorithms/src/Multiply.cpp
@@ -60,8 +60,8 @@ namespace Mantid
       Workspace_sptr out_work = boHelper.createOutputWorkspace(in_work1,in_work2);
 
       Workspace::iterator ti_out(*out_work);
-      Workspace::const_iterator ti_in1(*in_work1);
-      Workspace::const_iterator ti_in2(*in_work2);
+      Workspace::const_iterator ti_in1(*in_work1,boHelper.getRelativeLoopCount(in_work1,in_work2));
+      Workspace::const_iterator ti_in2(*in_work2,boHelper.getRelativeLoopCount(in_work2,in_work1));
       std::transform(ti_in1.begin(),ti_in1.end(),ti_in2.begin(),ti_out.begin(),Multiply_fn());
 
       // Assign it to the output workspace property
diff --git a/Code/Mantid/Algorithms/src/Plus.cpp b/Code/Mantid/Algorithms/src/Plus.cpp
index b3beaf2b19779ef6c712dd56ce8b5e449d1fb668..11276b757406e7b126b089e792230cdce06e4351 100644
--- a/Code/Mantid/Algorithms/src/Plus.cpp
+++ b/Code/Mantid/Algorithms/src/Plus.cpp
@@ -59,13 +59,9 @@ namespace Mantid
 
       Workspace_sptr out_work = boHelper.createOutputWorkspace(in_work1,in_work2);
 
-      Workspace2D_sptr workin1=boost::dynamic_pointer_cast<Workspace2D>(in_work1);
-      Workspace2D_sptr workin2=boost::dynamic_pointer_cast<Workspace2D>(in_work2);
-      Workspace2D_sptr workout=boost::dynamic_pointer_cast<Workspace2D>(out_work);
-    
       Workspace::iterator ti_out(*out_work);
-      Workspace::const_iterator ti_in1(*in_work1);
-      Workspace::const_iterator ti_in2(*in_work2);
+      Workspace::const_iterator ti_in1(*in_work1,boHelper.getRelativeLoopCount(in_work1,in_work2));
+      Workspace::const_iterator ti_in2(*in_work2,boHelper.getRelativeLoopCount(in_work2,in_work1));
       std::transform(ti_in1.begin(),ti_in1.end(),ti_in2.begin(),ti_out.begin(),Plus_fn());
 
       // Assign it to the output workspace property
diff --git a/Code/Mantid/Algorithms/test/BinaryOpHelperTest.h b/Code/Mantid/Algorithms/test/BinaryOpHelperTest.h
index c0f7399cd2f2226bce02adfd0658ab276a4cfac1..67a0ae77ecdac3e248056dc23a419ac981f32d13 100644
--- a/Code/Mantid/Algorithms/test/BinaryOpHelperTest.h
+++ b/Code/Mantid/Algorithms/test/BinaryOpHelperTest.h
@@ -139,6 +139,34 @@ public:
     checkOutputWorkspace(helper.createOutputWorkspace(work_in1,work_in7),work_in1,work_in7);
   }
 
+  void testgetRelativeLoopCount()
+  {
+    // Register the workspace in the data service
+    Workspace1D_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(10);
+    Workspace1D_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(20);
+    Workspace1D_sptr work_in3 = WorkspaceCreationHelper::Create1DWorkspaceFib(1);
+    Workspace2D_sptr work_in4 = WorkspaceCreationHelper::Create2DWorkspace(4,5);
+    Workspace2D_sptr work_in5 = WorkspaceCreationHelper::Create2DWorkspace(3,3);
+    Workspace2D_sptr work_in6 = WorkspaceCreationHelper::Create2DWorkspace(1,100);
+    Workspace2D_sptr work_in7 = WorkspaceCreationHelper::Create2DWorkspace(0,0);
+    BinaryOpHelper helper;
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in1,work_in2),2);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in2,work_in1),1);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in2,work_in2),1);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in1,work_in3),1);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in3,work_in1),10);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in2,work_in4),1);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in4,work_in2),1);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in5,work_in3),1);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in3,work_in5),9);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in6,work_in1),1);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in1,work_in6),10);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in6,work_in4),1);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in4,work_in6),5);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in7,work_in4),1);
+    TS_ASSERT_EQUALS(helper.getRelativeLoopCount(work_in4,work_in7),1);
+  }
+
 
   void checkOutputWorkspace(Workspace_sptr ws, Workspace_sptr wsIn1,Workspace_sptr wsIn2 ) const
   {
diff --git a/Code/Mantid/Algorithms/test/DivideTest.h b/Code/Mantid/Algorithms/test/DivideTest.h
index 605f84bf1e28061372c8aeda6d11fc45d10df9a5..496c5bd7436a0df5e13e0e5b27a3d2f859a00755 100644
--- a/Code/Mantid/Algorithms/test/DivideTest.h
+++ b/Code/Mantid/Algorithms/test/DivideTest.h
@@ -38,8 +38,8 @@ public:
     int sizex = 10;
     // Register the workspace in the data service
     AnalysisDataService* ADS = AnalysisDataService::Instance();
-    Workspace1D_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
-    Workspace1D_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
     ADS->add("test_in11", work_in1);
     ADS->add("test_in12", work_in2);
 
@@ -62,13 +62,13 @@ public:
 
   }
 
-  void xtestExec2D2D()
+  void testExec2D2D()
   {
     int sizex = 10,sizey=20;
     // Register the workspace in the data service
     AnalysisDataService* ADS = AnalysisDataService::Instance();
-    Workspace2D_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
-    Workspace2D_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
 
     Divide alg;
 
@@ -90,26 +90,69 @@ public:
     ADS->remove("test_out2");
 
   }
+  
+  void testExec1D2D()
+  {
+    int sizex = 10,sizey=20;
+    // Register the workspace in the data service
+    AnalysisDataService* ADS = AnalysisDataService::Instance();
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+
+    Divide alg;
+
+    std::string wsName1 = "test_in1D2D21";
+    std::string wsName2 = "test_in1D2D22";
+    std::string wsNameOut = "test_out1D2D";
+    ADS->add(wsName1, work_in1);
+    ADS->add(wsName2, work_in2);
+    alg.initialize();
+    alg.setPropertyValue("InputWorkspace_1",wsName1);
+    alg.setPropertyValue("InputWorkspace_2",wsName2);    
+    alg.setPropertyValue("OutputWorkspace",wsNameOut);
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+    TS_ASSERT( alg.isExecuted() );
+    Workspace_sptr work_out1;
+    TS_ASSERT_THROWS_NOTHING(work_out1 = ADS->retrieve(wsNameOut));
+
+    checkData(work_in1, work_in2, work_out1);
+
+    ADS->remove(wsName1);
+    ADS->remove(wsName2);
+    ADS->remove(wsNameOut);
+   
+  }
 
   void checkData( Workspace_sptr work_in1,  Workspace_sptr work_in2, Workspace_sptr work_out1)
   {
+    int ws2LoopCount;
+    if (work_in2->size() > 0)
+    {
+      ws2LoopCount = work_in1->size()/work_in2->size();
+    }
+    ws2LoopCount = (ws2LoopCount==0) ? 1 : ws2LoopCount;
+
     for (int i = 0; i < work_out1->size(); i++)
     {
+      checkDataItem(work_in1,work_in2,work_out1,i,i/ws2LoopCount);
+    }
+  }
+
+  void checkDataItem (Workspace_sptr work_in1,  Workspace_sptr work_in2, Workspace_sptr work_out1, int i, int ws2Index)
+  {
       double sig1 = work_in1->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
-      double sig2 = work_in2->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
+      double sig2 = work_in2->dataY(ws2Index/work_in1->blocksize())[ws2Index%work_in1->blocksize()];
       double sig3 = work_out1->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
       TS_ASSERT_DELTA(work_in1->dataX(i/work_in1->blocksize())[i%work_in1->blocksize()],
         work_out1->dataX(i/work_in1->blocksize())[i%work_in1->blocksize()], 0.0001);
       TS_ASSERT_DELTA(sig1 / sig2, sig3, 0.0001);
       double err1 = work_in1->dataE(i/work_in1->blocksize())[i%work_in1->blocksize()];
-      double err2 = work_in2->dataE(i/work_in2->blocksize())[i%work_in1->blocksize()];
+      double err2 = work_in2->dataE(ws2Index/work_in2->blocksize())[ws2Index%work_in1->blocksize()];
       double err3(sig3 * sqrt(((err1/sig1)*(err1/sig1)) + ((err2/sig2)*(err2/sig2))));     
       TS_ASSERT_DELTA(err3, work_out1->dataE(i/work_in1->blocksize())[i%work_in1->blocksize()], 0.0001);
-    }
   }
 
 
-
 };
 
 #endif /*DIVIDETEST_H_*/
diff --git a/Code/Mantid/Algorithms/test/MinusTest.h b/Code/Mantid/Algorithms/test/MinusTest.h
index 40c735cf6accfd52c2ba2a39b1c8399aa15a0e91..81ff45938bf914e9e435ddb04aa81cd9c0d3e779 100644
--- a/Code/Mantid/Algorithms/test/MinusTest.h
+++ b/Code/Mantid/Algorithms/test/MinusTest.h
@@ -38,8 +38,8 @@ public:
     int sizex = 10;
     // Register the workspace in the data service
     AnalysisDataService* ADS = AnalysisDataService::Instance();
-    Workspace1D_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
-    Workspace1D_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
     ADS->add("test_in11", work_in1);
     ADS->add("test_in12", work_in2);
 
@@ -67,8 +67,8 @@ public:
     int sizex = 10,sizey=20;
     // Register the workspace in the data service
     AnalysisDataService* ADS = AnalysisDataService::Instance();
-    Workspace2D_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
-    Workspace2D_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
 
     Minus alg;
 
@@ -91,24 +91,67 @@ public:
 
   }
 
+  void testExec1D2D()
+  {
+    int sizex = 10,sizey=20;
+    // Register the workspace in the data service
+    AnalysisDataService* ADS = AnalysisDataService::Instance();
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+
+    Minus alg;
+
+    std::string wsName1 = "test_in1D2D21";
+    std::string wsName2 = "test_in1D2D22";
+    std::string wsNameOut = "test_out1D2D";
+    ADS->add(wsName1, work_in1);
+    ADS->add(wsName2, work_in2);
+    alg.initialize();
+    alg.setPropertyValue("InputWorkspace_1",wsName1);
+    alg.setPropertyValue("InputWorkspace_2",wsName2);    
+    alg.setPropertyValue("OutputWorkspace",wsNameOut);
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+    TS_ASSERT( alg.isExecuted() );
+    Workspace_sptr work_out1;
+    TS_ASSERT_THROWS_NOTHING(work_out1 = ADS->retrieve(wsNameOut));
+
+    checkData(work_in1, work_in2, work_out1);
+
+    ADS->remove(wsName1);
+    ADS->remove(wsName2);
+    ADS->remove(wsNameOut);
+   
+  }
+
   void checkData( Workspace_sptr work_in1,  Workspace_sptr work_in2, Workspace_sptr work_out1)
   {
+    int ws2LoopCount;
+    if (work_in2->size() > 0)
+    {
+      ws2LoopCount = work_in1->size()/work_in2->size();
+    }
+    ws2LoopCount = (ws2LoopCount==0) ? 1 : ws2LoopCount;
+
     for (int i = 0; i < work_out1->size(); i++)
     {
+      checkDataItem(work_in1,work_in2,work_out1,i,i/ws2LoopCount);
+    }
+  }
+
+  void checkDataItem (Workspace_sptr work_in1,  Workspace_sptr work_in2, Workspace_sptr work_out1, int i, int ws2Index)
+  {
       double sig1 = work_in1->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
-      double sig2 = work_in2->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
+      double sig2 = work_in2->dataY(ws2Index/work_in1->blocksize())[ws2Index%work_in1->blocksize()];
       double sig3 = work_out1->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
       TS_ASSERT_DELTA(work_in1->dataX(i/work_in1->blocksize())[i%work_in1->blocksize()],
         work_out1->dataX(i/work_in1->blocksize())[i%work_in1->blocksize()], 0.0001);
       TS_ASSERT_DELTA(sig1 - sig2, sig3, 0.0001);
       double err1 = work_in1->dataE(i/work_in1->blocksize())[i%work_in1->blocksize()];
-      double err2 = work_in2->dataE(i/work_in2->blocksize())[i%work_in1->blocksize()];
+      double err2 = work_in2->dataE(ws2Index/work_in2->blocksize())[ws2Index%work_in1->blocksize()];
       double err3(sqrt((err1*err1) + (err2*err2)));     
       TS_ASSERT_DELTA(err3, work_out1->dataE(i/work_in1->blocksize())[i%work_in1->blocksize()], 0.0001);
-    }
   }
 
-
 };
 
 #endif /*MINUSTEST_H_*/
diff --git a/Code/Mantid/Algorithms/test/MultiplyTest.h b/Code/Mantid/Algorithms/test/MultiplyTest.h
index 60d89fae537c044ad177b29e9bd7b89197540a01..9b717b1b1ea00d9ea498e4a4c57d188f61220584 100644
--- a/Code/Mantid/Algorithms/test/MultiplyTest.h
+++ b/Code/Mantid/Algorithms/test/MultiplyTest.h
@@ -38,8 +38,8 @@ public:
     int sizex = 5;
     // Register the workspace in the data service
     AnalysisDataService* ADS = AnalysisDataService::Instance();
-    Workspace1D_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
-    Workspace1D_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
     ADS->add("test_in11", work_in1);
     ADS->add("test_in12", work_in2);
 
@@ -91,27 +91,103 @@ public:
 
   }
 
+  void testExec1D2D()
+  {
+    int sizex = 10,sizey=20;
+    // Register the workspace in the data service
+    AnalysisDataService* ADS = AnalysisDataService::Instance();
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+
+    Multiply alg;
+
+    std::string wsName1 = "test_in1D2D21";
+    std::string wsName2 = "test_in1D2D22";
+    std::string wsNameOut = "test_out1D2D";
+    ADS->add(wsName1, work_in1);
+    ADS->add(wsName2, work_in2);
+    alg.initialize();
+    alg.setPropertyValue("InputWorkspace_1",wsName1);
+    alg.setPropertyValue("InputWorkspace_2",wsName2);    
+    alg.setPropertyValue("OutputWorkspace",wsNameOut);
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+    TS_ASSERT( alg.isExecuted() );
+    Workspace_sptr work_out1;
+    TS_ASSERT_THROWS_NOTHING(work_out1 = ADS->retrieve(wsNameOut));
+
+    checkData(work_in1, work_in2, work_out1);
+
+    ADS->remove(wsName1);
+    ADS->remove(wsName2);
+    ADS->remove(wsNameOut);
+   
+  }
+
+  void testExec2D1D()
+  {
+    int sizex = 5,sizey=300;
+    // Register the workspace in the data service
+    AnalysisDataService* ADS = AnalysisDataService::Instance();
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+
+    Multiply alg;
+
+    std::string wsName1 = "test_in2D1D21";
+    std::string wsName2 = "test_in2D1D22";
+    std::string wsNameOut = "test_out2D1D";
+    ADS->add(wsName1, work_in1);
+    ADS->add(wsName2, work_in2);
+    alg.initialize();
+    alg.setPropertyValue("InputWorkspace_1",wsName1);
+    alg.setPropertyValue("InputWorkspace_2",wsName2);    
+    alg.setPropertyValue("OutputWorkspace",wsNameOut);
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+    TS_ASSERT( alg.isExecuted() );
+    Workspace_sptr work_out1;
+    TS_ASSERT_THROWS_NOTHING(work_out1 = ADS->retrieve(wsNameOut));
+
+    checkData(work_in2, work_in1, work_out1);
+
+    ADS->remove(wsName1);
+    ADS->remove(wsName2);
+    ADS->remove(wsNameOut);
+   
+  }
+
+
   void checkData( Workspace_sptr work_in1,  Workspace_sptr work_in2, Workspace_sptr work_out1)
   {
+    int ws2LoopCount;
+    if (work_in2->size() > 0)
+    {
+      ws2LoopCount = work_in1->size()/work_in2->size();
+    }
+    ws2LoopCount = (ws2LoopCount==0) ? 1 : ws2LoopCount;
+
     for (int i = 0; i < work_out1->size(); i++)
     {
+      checkDataItem(work_in1,work_in2,work_out1,i,i/ws2LoopCount);
+    }
+  }
+
+  void checkDataItem (Workspace_sptr work_in1,  Workspace_sptr work_in2, Workspace_sptr work_out1, int i, int ws2Index)
+  {
       double sig1 = work_in1->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
-      double sig2 = work_in2->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
+      double sig2 = work_in2->dataY(ws2Index/work_in1->blocksize())[ws2Index%work_in1->blocksize()];
       double sig3 = work_out1->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
       TS_ASSERT_DELTA(work_in1->dataX(i/work_in1->blocksize())[i%work_in1->blocksize()],
         work_out1->dataX(i/work_in1->blocksize())[i%work_in1->blocksize()], 0.0001);
       TS_ASSERT_DELTA(sig1 * sig2, sig3, 0.0001);
       double err1 = work_in1->dataE(i/work_in1->blocksize())[i%work_in1->blocksize()];
-      double err2 = work_in2->dataE(i/work_in2->blocksize())[i%work_in1->blocksize()];
+      double err2 = work_in2->dataE(ws2Index/work_in2->blocksize())[ws2Index%work_in1->blocksize()]; 
       // (Sa/a)2 + (Sb/b)2 = (Sc/c)2 
       //  So after taking proportions, squaring, summing, 
       //  and taking the square root, you get a proportional error to the product c. Multiply that proportional error by c to get the actual standard deviation Sc. 
       double err3(sig3 * sqrt(((err1/sig1)*(err1/sig1)) + ((err2/sig2)*(err2/sig2))));     
       TS_ASSERT_DELTA(err3, work_out1->dataE(i/work_in1->blocksize())[i%work_in1->blocksize()], 0.0001);
-    }
   }
 
-
 };
 
 #endif /*MULTIPLYTEST_H_*/
diff --git a/Code/Mantid/Algorithms/test/PlusTest.h b/Code/Mantid/Algorithms/test/PlusTest.h
index 57ccf98906e22f44ae58366fad6adf684394a6be..7ffaa172f33bef93cfd872a9d260075cb4c90a67 100644
--- a/Code/Mantid/Algorithms/test/PlusTest.h
+++ b/Code/Mantid/Algorithms/test/PlusTest.h
@@ -38,8 +38,8 @@ public:
     int sizex = 10;
     // Register the workspace in the data service
     AnalysisDataService* ADS = AnalysisDataService::Instance();
-    Workspace1D_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
-    Workspace1D_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
     ADS->add("test_in11", work_in1);
     ADS->add("test_in12", work_in2);
 
@@ -67,8 +67,8 @@ public:
     int sizex = 10,sizey=20;
     // Register the workspace in the data service
     AnalysisDataService* ADS = AnalysisDataService::Instance();
-    Workspace2D_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
-    Workspace2D_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace123(sizex,sizey);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
 
     Plus plus_alg;
 
@@ -91,23 +91,99 @@ public:
    
   }
 
+  
+  void testExec1D2D()
+  {
+    int sizex = 10,sizey=20;
+    // Register the workspace in the data service
+    AnalysisDataService* ADS = AnalysisDataService::Instance();
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+
+    Plus plus_alg;
+
+    std::string wsName1 = "test_in1D2D21";
+    std::string wsName2 = "test_in1D2D22";
+    std::string wsNameOut = "test_out1D2D";
+    ADS->add(wsName1, work_in1);
+    ADS->add(wsName2, work_in2);
+    plus_alg.initialize();
+    plus_alg.setPropertyValue("InputWorkspace_1",wsName1);
+    plus_alg.setPropertyValue("InputWorkspace_2",wsName2);    
+    plus_alg.setPropertyValue("OutputWorkspace",wsNameOut);
+    TS_ASSERT_THROWS_NOTHING(plus_alg.execute());
+    TS_ASSERT( plus_alg.isExecuted() );
+    Workspace_sptr work_out1;
+    TS_ASSERT_THROWS_NOTHING(work_out1 = ADS->retrieve(wsNameOut));
+
+    checkData(work_in1, work_in2, work_out1);
+
+    ADS->remove(wsName1);
+    ADS->remove(wsName2);
+    ADS->remove(wsNameOut);
+   
+  }
+
+  void testExec2D1D()
+  {
+    int sizex = 5,sizey=300;
+    // Register the workspace in the data service
+    AnalysisDataService* ADS = AnalysisDataService::Instance();
+    Workspace_sptr work_in2 = WorkspaceCreationHelper::Create1DWorkspaceFib(sizex);
+    Workspace_sptr work_in1 = WorkspaceCreationHelper::Create2DWorkspace154(sizex,sizey);
+
+    Plus plus_alg;
+
+    std::string wsName1 = "test_in2D1D21";
+    std::string wsName2 = "test_in2D1D22";
+    std::string wsNameOut = "test_out2D1D";
+    ADS->add(wsName1, work_in1);
+    ADS->add(wsName2, work_in2);
+    plus_alg.initialize();
+    plus_alg.setPropertyValue("InputWorkspace_1",wsName1);
+    plus_alg.setPropertyValue("InputWorkspace_2",wsName2);    
+    plus_alg.setPropertyValue("OutputWorkspace",wsNameOut);
+    TS_ASSERT_THROWS_NOTHING(plus_alg.execute());
+    TS_ASSERT( plus_alg.isExecuted() );
+    Workspace_sptr work_out1;
+    TS_ASSERT_THROWS_NOTHING(work_out1 = ADS->retrieve(wsNameOut));
+
+    checkData(work_in2, work_in1, work_out1);
+
+    ADS->remove(wsName1);
+    ADS->remove(wsName2);
+    ADS->remove(wsNameOut);
+   
+  }
+
   void checkData( Workspace_sptr work_in1,  Workspace_sptr work_in2, Workspace_sptr work_out1)
   {
+    int ws2LoopCount;
+    if (work_in2->size() > 0)
+    {
+      ws2LoopCount = work_in1->size()/work_in2->size();
+    }
+    ws2LoopCount = (ws2LoopCount==0) ? 1 : ws2LoopCount;
+
     for (int i = 0; i < work_out1->size(); i++)
     {
+      checkDataItem(work_in1,work_in2,work_out1,i,i/ws2LoopCount);
+    }
+  }
+
+  void checkDataItem (Workspace_sptr work_in1,  Workspace_sptr work_in2, Workspace_sptr work_out1, int i, int ws2Index)
+  {
       double sig1 = work_in1->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
-      double sig2 = work_in2->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
+      double sig2 = work_in2->dataY(ws2Index/work_in1->blocksize())[ws2Index%work_in1->blocksize()];
       double sig3 = work_out1->dataY(i/work_in1->blocksize())[i%work_in1->blocksize()];
       TS_ASSERT_DELTA(work_in1->dataX(i/work_in1->blocksize())[i%work_in1->blocksize()],
         work_out1->dataX(i/work_in1->blocksize())[i%work_in1->blocksize()], 0.0001);
       TS_ASSERT_DELTA(sig1 + sig2, sig3, 0.0001);
       double err1 = work_in1->dataE(i/work_in1->blocksize())[i%work_in1->blocksize()];
-      double err2 = work_in2->dataE(i/work_in2->blocksize())[i%work_in1->blocksize()];
+      double err2 = work_in2->dataE(ws2Index/work_in2->blocksize())[ws2Index%work_in1->blocksize()];
       double err3(sqrt((err1*err1) + (err2*err2)));     
       TS_ASSERT_DELTA(err3, work_out1->dataE(i/work_in1->blocksize())[i%work_in1->blocksize()], 0.0001);
-    }
   }
-
   
 };
 
diff --git a/Code/Mantid/DataObjects/test/TripleIteratorTest.h b/Code/Mantid/DataObjects/test/TripleIteratorTest.h
index f7da5d49216ec9297f701b780a160246acd74c5c..6ccec13bbd349f5ce0d50525fb94ae30b44e1233 100644
--- a/Code/Mantid/DataObjects/test/TripleIteratorTest.h
+++ b/Code/Mantid/DataObjects/test/TripleIteratorTest.h
@@ -90,12 +90,11 @@ public:
     for(Workspace1D::const_iterator ti(*workspace); ti != ti.end(); ++ti)
     {
       TS_ASSERT_THROWS_NOTHING
-        (
+      (
         TripleRef<double> tr = *ti;
-      double d1 = tr[0];
-      double d2 = tr[1];
-      double d3 = tr[2];
-      d1++;d2++;d3++;
+        TS_ASSERT_EQUALS(tr[0],workspace->dataX(0)[count]);
+        TS_ASSERT_EQUALS(tr[1],workspace->dataY(0)[count]);
+        TS_ASSERT_EQUALS(tr[2],workspace->dataE(0)[count]);
       )
         count++;
     }
@@ -136,10 +135,10 @@ public:
       TS_ASSERT_THROWS_NOTHING
         (
         TripleRef<double> tr = *ti;
-      double d1 = tr[0];
-      double d2 = tr[1];
-      double d3 = tr[2];
-      d1++;d2++;d3++;
+
+        TS_ASSERT_EQUALS(tr[0],workspace->dataX(0)[count]);
+        TS_ASSERT_EQUALS(tr[1],workspace->dataY(0)[count]);
+        TS_ASSERT_EQUALS(tr[2],workspace->dataE(0)[count]);
       )
         count++;
     }
@@ -157,12 +156,13 @@ public:
     for(Workspace::const_iterator ti(*workspace); ti != ti.end(); ++ti)
     {
       TS_ASSERT_THROWS_NOTHING
-        (
+      (
         TripleRef<double> tr = *ti;
-      double d1 = tr[0];
-      double d2 = tr[1];
-      double d3 = tr[2];
-      d1++;d2++;d3++;
+        int datablock = count/size;
+        int blockindex = count%size;
+        TS_ASSERT_EQUALS(tr[0],workspace->dataX(datablock)[blockindex]);
+        TS_ASSERT_EQUALS(tr[1],workspace->dataY(datablock)[blockindex]);
+        TS_ASSERT_EQUALS(tr[2],workspace->dataE(datablock)[blockindex]);
       )
         count++;
     }
@@ -220,6 +220,73 @@ public:
     return;
   }
 
+  void testLoopIteratorWorkspace1D()
+  {
+    int size = 13;
+    const int loopCountArrayLength = 6;
+    int loopCountArray[loopCountArrayLength];
+    loopCountArray[0] = 1;
+    loopCountArray[1] = 2;
+    loopCountArray[2] = 3;
+    loopCountArray[3] = 5;
+    loopCountArray[4] = 11;
+    loopCountArray[5] = 0;
+    
+    Wbase workspace = Create1DWorkspace(size);
+
+    for (int i = 0; i < loopCountArrayLength; i++)
+    {
+      int loopCount = loopCountArray[i];
+      int count = 0;
+      for(Workspace::const_iterator ti(*workspace,loopCount); ti != ti.end(); ++ti)
+      {
+        TS_ASSERT_THROWS_NOTHING
+        (
+          TripleRef<double> tr = *ti;
+          TS_ASSERT_EQUALS(tr[0],workspace->dataX(0)[count%size]);
+          TS_ASSERT_EQUALS(tr[1],workspace->dataY(0)[count%size]);
+          TS_ASSERT_EQUALS(tr[2],workspace->dataE(0)[count%size]);
+        )
+          count++;
+      }
+      TS_ASSERT_EQUALS(count,size*loopCount);
+    }
+  }
+
+  void testLoopIteratorWorkspace2D()
+  {
+    int size = 57;
+    int histogramCount = 100;
+    Wbase workspace = Create2DWorkspace(histogramCount,size);
+
+    const int loopCountArrayLength = 4;
+    int loopCountArray[loopCountArrayLength];
+    loopCountArray[0] = 1;
+    loopCountArray[1] = 2;
+    loopCountArray[2] = 3;
+    loopCountArray[3] = 0;
+    
+    for (int i = 0; i < loopCountArrayLength; i++)
+    {
+      int loopCount = loopCountArray[i];
+      int count = 0;
+      for(Workspace::const_iterator ti(*workspace,loopCount); ti != ti.end(); ++ti)
+      {
+        TS_ASSERT_THROWS_NOTHING
+        (
+          TripleRef<double> tr = *ti;
+          int indexPosition = count%(size*histogramCount);
+          int datablock = indexPosition/size;
+          int blockindex = indexPosition%size;
+          TS_ASSERT_EQUALS(tr[0],workspace->dataX(datablock)[blockindex]);
+          TS_ASSERT_EQUALS(tr[1],workspace->dataY(datablock)[blockindex]);
+          TS_ASSERT_EQUALS(tr[2],workspace->dataE(datablock)[blockindex]);
+        )
+          count++;
+      }
+      TS_ASSERT_EQUALS(count,size*histogramCount*loopCount);
+    }
+  }
 
 };
 #endif /*TRIPLEITERATORTEST_*/
diff --git a/Code/Mantid/Main/Benchmark.cpp b/Code/Mantid/Main/Benchmark.cpp
index ae32ad80e3467b569ee0453a682d3506fa951ef1..3a7eb2869d45558df818201e8a299c1dcc4b2670 100644
--- a/Code/Mantid/Main/Benchmark.cpp
+++ b/Code/Mantid/Main/Benchmark.cpp
@@ -70,13 +70,16 @@ using full iterator method  : ~52 seconds
 An identical fortran operation using LIBISIS takes ~0.7 seconds
 
 */
-
-
-
 void Benchmark::RunPlusTest()
 {
+  RunPlusTest(2000,2584);
+}
+
 
-  int sizex = 2000,sizey=2584;
+void Benchmark::RunPlusTest(int detectorCount, int timeBinCount)
+{
+  int sizex = detectorCount;
+  int sizey = timeBinCount;
   // Register the workspace in the data service
   AnalysisDataService* ADS = AnalysisDataService::Instance();
 
diff --git a/Code/Mantid/Main/Benchmark.h b/Code/Mantid/Main/Benchmark.h
index 96d4574bda4ae4ce811c5dc66478e737d5b70f4c..84cccd76b679ee415b67fa8a40ce3e3a3164cb67 100644
--- a/Code/Mantid/Main/Benchmark.h
+++ b/Code/Mantid/Main/Benchmark.h
@@ -47,6 +47,8 @@ public:
 
   /// Runs a timed addition of two workspaces
   void RunPlusTest();
+  /// Runs a timed addition of two workspaces
+  void RunPlusTest(int detectorCount, int timeBinCount);
 
   static Mantid::DataObjects::Workspace2D_sptr Create2DWorkspace(int xlen, int ylen);
 
diff --git a/Code/Mantid/Main/Main.cpp b/Code/Mantid/Main/Main.cpp
index 4c244a354adb652487174063f1624b5364e930b7..85b54c34e7a1db4085792a58c065783a3f6c7cfc 100644
--- a/Code/Mantid/Main/Main.cpp
+++ b/Code/Mantid/Main/Main.cpp
@@ -17,7 +17,7 @@ int main()
 {
 
   FrameworkManager fm;
-  fm.initialize();
+  //fm.initialize();
 
   Benchmark b;
   b.RunPlusTest();