Exemple #1
0
void test9(void) {
  ElementNode_handle pE1=0,pE2=0,pRes;
  int i;
  printf("\n==== VECTOR ADDITION 2 =================\n");
  for(i=0;i<5;++i) insert_element(&pE1,2000*i,i);

  for(i=0;i<10;++i) insert_element(&pE2,1000*i,i);
 

  pRes=add(pE1,pE2);
  printf("pE1 + pE2 = \n"); 
  printf("raw:\n"); print_elements(pRes); printf("\n");
  free_elements(pRes);

  pRes=add(pE2,pE1);
  printf("pE2 + pE1 = \n"); 
  printf("raw:\n"); print_elements(pRes); printf("\n"); 
  free_elements(pRes);

  pRes=add(pE1,pE1);
  printf("pE1 + pE1 = \n");
   printf("raw:\n"); print_elements(pRes); printf("\n"); 
  free_elements(pRes);

  free_elements(pE1);
  free_elements(pE2);
}
Exemple #2
0
void test6(void) {
  ElementNode_handle pE1=0,pE2=0,pE3=0;
  int i;
  printf("\n==== SCALAR MULTIPLICATION =================\n");
  for(i=0;i<20;++i) insert_element(&pE1,i,i*i);
  printf("vector pE1 formatted:\n");
  printf_elements(pE1,"%4d",20); printf("\n");

  for(i=0;i<20;++i) insert_element(&pE2,40-2*i,i);
  printf("vector pE2 formatted:\n");
  printf_elements(pE2,"%4d",40); printf("\n");
 
  for(i=0;i<20;++i) {
    if (i%2) insert_element(&pE3,2*i,i);
    else     insert_element(&pE3,41-2*i,-i);
  }
  printf("vector pE3 formatted:\n");
  printf_elements(pE3,"%4d",40); printf("\n");
  printf("scalar product pE1 and pE2 = %i\n",scalar_product(pE1,pE2));
  printf("scalar product pE2 and pE3 = %i\n",scalar_product(pE2,pE3));
  printf("scalar product pE3 and pE1 = %i\n",scalar_product(pE3,pE1));
  printf("scalar product pE1 and pE1 = %i\n",scalar_product(pE1,pE1));

  free_elements(pE1);
  free_elements(pE2);
  free_elements(pE3);
}
Exemple #3
0
static int		move_to_env_suite(t_env *env, char *cat,
		char *pwd, char *oldpwd)
{
	char	*tmp;

	tmp = NULL;
	if (cat)
	{
		tmp = pwd;
		pwd = ft_strjoin(pwd, cat);
		ft_memdel((void**)&tmp);
	}
	if (pwd && chdir(pwd) == 0)
	{
		move_old_and_pwd(env, oldpwd, pwd);
		free_elements(pwd, cat, NULL, NULL);
		return (0);
	}
	else
	{
		cant_move_home();
		free_elements(pwd, cat, NULL, NULL);
		return (1);
	}
}
void test10( void )
{
    ElementNode * pE1=0, *pE2=0, *pRes;
    int i;
    printf( "\n==== VECTOR ADDITION (ZEROES) ========\n" );
    for( i=0; i<20; ++i ) insert_element( &pE1,i,i*i );
    printf( "vector pE1 formatted:\n" );
    printf_elements( pE1,"%4d",20 );
    printf( "\n" );
    for( i=0; i<20; ++i ) insert_element( &pE2,i,-i*i );
    printf( "vector pE2 formatted:\n" );
    printf_elements( pE2,"%4d",20 );
    printf( "\n" );
    pRes=add( pE1,pE2 );
    printf( "pE1 + pE2 = \n" );
    printf_elements( pRes,"%4d",20 );
    printf( "\n" );
    printf( "raw:\n" );
    print_elements( pRes );
    printf( "\n" );
    free_elements( pRes );
    pRes=add( pE2,pE1 );
    printf( "pE2 + pE1 = \n" );
    printf_elements( pRes,"%4d",20 );
    printf( "\n" );
    printf( "raw:\n" );
    print_elements( pRes );
    printf( "\n" );
    free_elements( pRes );
    free_elements( pE1 );
    free_elements( pE2 );
}
void test7( void )
{
    ElementNode * pE1=0, *pE2=0;
    int i;
    printf( "\n==== SCALAR MULTIPLICATION 2 =================\n" );
    for( i=0; i<20; ++i ) insert_element( &pE1,1000*i,i*i );
    for( i=0; i<20; ++i ) insert_element( &pE2,500*i,i );
    printf( "scalar product pE1 and pE2 = %i\n",scalar_product( pE1,pE2 ) );
    printf( "scalar product pE2 and pE1 = %i\n",scalar_product( pE2,pE1 ) );
    printf( "scalar product pE1 and pE1 = %i\n",scalar_product( pE1,pE1 ) );
    free_elements( pE1 );
    free_elements( pE2 );
}
Exemple #6
0
void free_rows( RowNode_handle p_r )
{
    /* pointer to the columns */
  ElementNode_handle pColumn;
  
    /* pointer to traverse the rows */
  RowNode_handle TempRow;
  
    /* validate matrix exists */
  if(!p_r)
    return;
  
    /* while rows are valid */
  while(p_r)
  {
      /* assign column pointer to start of column */
    pColumn = p_r->elements;
    
      /* delete this row */
    free_elements(pColumn);
      
      /* move to next row */
    TempRow = p_r->next;
    
      /* free current row, after columns have been freed */
    free(p_r);
    
      /* move to new current row */
    p_r = TempRow;
  }
}
Exemple #7
0
static int		move_to_env(t_env *environ, char *env, char *av)
{
	char	*oldpwd;
	char	*pwd;
	char	buffer[256];
	char	*cat;
	char	*tmp;

	cat = NULL;
	tmp = NULL;
	pwd = NULL;
	if (!ft_strcmp(env, "OLDPWD") && ft_strlen(av) > 0)
	{
		tmp = ft_strsub(av, 1, ft_strlen(av));
		cat = ft_strdup(tmp);
		av = ft_strdup(tmp);
	}
	oldpwd = getcwd(buffer, 256);
	pwd = return_env(environ->environ, env);
	if (!pwd)
	{
		cant_move_home();
		move_old_and_pwd(environ, oldpwd, pwd);
		free_elements(pwd, cat, tmp, NULL);
		return (1);
	}
	ft_memdel((void**)&tmp);
	ft_memdel((void**)&av);
	return (move_to_env_suite(environ, cat, pwd, oldpwd));
}
Exemple #8
0
void test12(void) {
  ElementNode_handle pE1=0;
  int pos=10000;
  printf("\n==== TESTING FIND 2 ========\n");
  insert_element(&pE1,pos,5);
  print_elements(pE1); printf("\n");

  printf ("value %i at position %i\n",get(pE1,pos),pos);
  free_elements(pE1);
}
Exemple #9
0
void test11(void) {
  ElementNode_handle pE1=0;
  int i;
  printf("\n==== TESTING FIND ========\n");
  for(i=0;i<20;i+=2) insert_element(&pE1,i,i*i);
  printf_elements(pE1,"%4d",20); printf("\n");
  printf("print vector using get - very inefficient!!!\n");
  for(i=0;i<20;++i) printf("index %i, value %i\n",i,get(pE1,i));
  free_elements(pE1);
}
Exemple #10
0
void test0(void) {
  ElementNode_handle pE1=0;
  int i;
  printf("\n====== INSERTS BACK =============================\n");
  for(i=0;i<20;++i) insert_element(&pE1,3*i,i*i);
  printf("vector 1 formatted:\n");
  printf_elements(pE1,"%4d",80); printf("\n");
  printf("vector 1 raw:\n");
  print_elements(pE1); printf("\n");

  free_elements(pE1);
}
Exemple #11
0
void test1(void) {
  ElementNode_handle pE2=0;
  int i;
  printf("\n====== INSERTS BACK =============================\n");

  for(i=0;i<20;++i) insert_element(&pE2,20-i,i);
  printf("vector 2 formatted:\n");
  printf_elements(pE2,"%4d",20); printf("\n");
  printf("vector 2 raw:\n");
  print_elements(pE2); printf("\n");
 
  free_elements(pE2);
}
Exemple #12
0
void test2(void) {
  ElementNode_handle pE3=0;
  int i;
  printf("\n====== INSERTS MIDDLE =============================\n");
 
  for(i=0;i<20;++i) {
    if (i%2) insert_element(&pE3,i,i);
    else     insert_element(&pE3,20-i,-i);
  }
  printf("vector 3 formatted:\n");
  printf_elements(pE3,"%4d",20); printf("\n");
  printf("vector 3 raw:\n");
  print_elements(pE3); printf("\n");

  free_elements(pE3);
}
Exemple #13
0
void test3(void) {
  ElementNode_handle pE2=0;
  int i;
  printf("\n====== DELETE FRONT ====================\n");
  for(i=0;i<5;++i) insert_element(&pE2,i,i+1); /*no 0s in the list*/
  printf("vector 2 formatted:\n");
  printf_elements(pE2,"%4d",5); printf("\n");
  printf("vector 2 raw:\n");
  print_elements(pE2); printf("\n");
 
  delete_element(&pE2,0);
  printf("vector 2 formatted:\n");
  printf_elements(pE2,"%4d",5); printf("\n");
  printf("vector 2 raw:\n");
  print_elements(pE2); printf("\n");

  free_elements(pE2);
}
Exemple #14
0
void			replace_char(t_it *it, char cmd[2])
{
	int		size;
	char	*tmp2;
	char	*tmp3;
	char	*tmp;
	int		j;

	j = 0;
	tmp = ft_memalloc(sizeof(char) * (it->i + 3));
	ft_strncpy(tmp, it->line, it->i);
	tmp[it->i + 1] = '\0';
	tmp = ft_strcat(tmp, cmd);
	tmp3 = copy_end_line(j, it->i, it->line);
	tmp2 = ft_strjoin(tmp, tmp3);
	ft_memdel((void**)&it->line);
	it->line = ft_strdup(tmp2);
	multi_line_text(it);
	size = ((it->len + 1) + it->offset) + 1;
	if (!(size % (it->ws_col)))
		tputs(tgetstr(RIGHT, NULL), 0, my_putchar);
	free_elements(tmp, tmp2, tmp3, NULL);
}
void test8( void )
{
    ElementNode * pE1=0, *pE2=0, *pE3=0, *pRes;
  int i;
  printf("\n==== VECTOR ADDITION =================\n");
  for(i=0;i<20;++i) insert_element(&pE1,i,i*i);
  printf("vector pE1 formatted:\n");
  printf_elements(pE1,"%4d",20); printf("\n");

  for(i=0;i<10;++i) insert_element(&pE2,20-2*i,i);
  printf("vector pE2 formatted:\n");
  printf_elements(pE2,"%4d",20); printf("\n");
 
  for(i=0;i<5;++i) {
    if (i%2) insert_element(&pE3,4*i,i);
    else     insert_element(&pE3,21-4*i,-i);
  }
  printf("vector pE3 formatted:\n");
  printf_elements(pE3,"%4d",20); printf("\n");

  pRes=add(pE1,pE2);
  printf("pE1 + pE2 = \n"); printf_elements(pRes,"%4d",20); printf("\n");
  /* printf("raw:\n"); print_elements(pRes); printf("\n"); */
  free_elements(pRes);
  pRes=add(pE2,pE3);
  printf("pE2 + pE3 = \n"); printf_elements(pRes,"%4d",20); printf("\n");
  /* printf("raw:\n"); print_elements(pRes); printf("\n"); */
  free_elements(pRes);
  pRes=add(pE3,pE1);
  printf("pE3 + pE1 = \n"); printf_elements(pRes,"%4d",20); printf("\n");
  /* printf("raw:\n"); print_elements(pRes); printf("\n"); */
  free_elements(pRes);
  pRes=add(pE1,pE3);
  printf("pE1 + pE3 = \n"); printf_elements(pRes,"%4d",20); printf("\n");
  /* printf("raw:\n"); print_elements(pRes); printf("\n"); */
  free_elements(pRes);
  free_elements(pE1);
  free_elements(pE2);
  free_elements(pE3);
}
Exemple #16
0
matr_sums::~matr_sums() 
{
	delete weights;
	free_elements(matrices->begin(), matrices->end());
	delete matrices;
};
void test(const Cont &)
{
  // Testing if all types are provided.

  typename Cont::value_type              t0;
  typename Cont::reference               t1 = t0;      CGAL_USE(t1);
  typename Cont::const_reference         t2 = t0;      CGAL_USE(t2);
  typename Cont::pointer                 t3 = &t0;
  typename Cont::const_pointer           t4 = &t0;     CGAL_USE(t4);
  typename Cont::size_type               t5 = 0;       CGAL_USE(t5);
  typename Cont::difference_type         t6 = t3-t3;   CGAL_USE(t6);
  typename Cont::iterator                t7;           CGAL_USE(t7);
  typename Cont::const_iterator          t8;           CGAL_USE(t8);
  typename Cont::reverse_iterator        t9;           CGAL_USE(t9);
  typename Cont::const_reverse_iterator  t10;          CGAL_USE(t10);
  typename Cont::allocator_type          t15;

  std::cout << "Testing empty containers." << std::endl;

  Cont c0, c1;
  Cont c2(t15);
  Cont c3(c2);
  Cont c4;
  c4 = c2;

  typedef std::vector<typename Cont::value_type> Vect;
  Vect v0;
  const Cont c5(v0.begin(), v0.end());
  Cont c6(c5.begin(), c5.end());
  typename Cont::allocator_type Al;
  Cont c7(c0.begin(), c0.end(), Al);
  Cont c8;
  c8.insert(c0.rbegin(), c0.rend());

  // test conversion iterator-> const_iterator.
  typename Cont::const_iterator t16 = c5.begin();  CGAL_USE(t16);
  assert(t16 == c5.begin());

  assert(c0 == c1);
  assert(! (c0 < c1));

  assert(check_empty(c0));
  assert(check_empty(c1));
  assert(check_empty(c2));
  assert(check_empty(c3));
  assert(check_empty(c4));
  assert(check_empty(c5));
  assert(check_empty(c6));
  assert(check_empty(c7));
  assert(check_empty(c8));

  c1.swap(c0);

  assert(check_empty(c0));
  assert(check_empty(c1));

  c1.merge(c0);

  assert(check_empty(c0));
  assert(check_empty(c1));

  typename Cont::allocator_type  t20 = c0.get_allocator();

  std::cout << "Now filling some containers" << std::endl;

  Vect v1(10000);
  Cont c9(v1.begin(), v1.end());

  assert(c9.size() == v1.size());
  assert(c9.max_size() >= v1.size());
  assert(c9.capacity() >= c9.size());

  Cont c10 = c9;

  assert(c10 == c9);
  assert(c10.size() == v1.size());
  assert(c10.max_size() >= v1.size());
  assert(c10.capacity() >= c10.size());

  c9.clear();

  assert(check_empty(c9));
  assert(c9.capacity() >= c9.size());
  assert(c0 == c9);

  c9.merge(c10);
  c10.swap(c9);

  assert(check_empty(c9));
  assert(c9.capacity() >= c9.size());

  assert(c10.size() == v1.size());
  assert(c10.max_size() >= v1.size());
  assert(c10.capacity() >= c10.size());

  std::cout << "Testing insertion methods" << std::endl;

  c9.assign(c10.begin(), c10.end());

  assert(c9 == c10);

  c10.assign(c9.begin(), c9.end());

  assert(c9 == c10);

  c9.insert(c10.begin(), c10.end());

  assert(c9.size() == 2*v1.size());

  c9.clear();

  assert(c9 != c10);

  c9.insert(c10.begin(), c10.end());

  assert(c9.size() == v1.size());
  assert(c9 == c10);


  typename Cont::iterator it = c9.iterator_to(*c9.begin());
  assert(it == c9.begin());
  typename Cont::const_iterator cit = c9.iterator_to(const_cast<typename Cont::const_reference>(*c9.begin()));
  assert(cit == c9.begin());

  typename Cont::iterator s_it = Cont::s_iterator_to(*c9.begin());
  assert(s_it == c9.begin());
  typename Cont::const_iterator s_cit = Cont::s_iterator_to(const_cast<typename Cont::const_reference>(*c9.begin()));
  assert(s_cit == c9.begin());


  c10 = Cont();

  assert(check_empty(c10));

  for(typename Vect::const_iterator it = v1.begin(); it != v1.end(); ++it)
    c10.insert(*it);

  assert(c10.size() == v1.size());
  assert(c9 == c10);

  c9.erase(c9.begin());
  c9.erase(c9.begin());

  assert(c9.size() == v1.size() - 2);

  // test reserve
  /*Cont c11;
  c11.reserve(v1.size());
  for(typename Vect::const_iterator it = v1.begin(); it != v1.end(); ++it)
    c11.insert(*it);
  
  assert(c11.size() == v1.size());
  assert(c10 == c11);*/

  // owns() and owns_dereferencable().
  for(typename Cont::const_iterator it = c9.begin(), end = c9.end(); it != end; ++it) {
    assert(c9.owns(it));
    assert(c9.owns_dereferencable(it));
    assert(! c10.owns(it));
    assert(! c10.owns_dereferencable(it));
  }
  assert(c9.owns(c9.end()));
  assert(! c9.owns_dereferencable(c9.end()));


  c9.erase(c9.begin(), c9.end());

  assert(check_empty(c9));
  
  std::cout << "Testing parallel insertion" << std::endl;
  {
  Cont c11;
  Vect v11(1000000);
  std::vector<typename Cont::iterator> iterators(v11.size());
  tbb::parallel_for(
    tbb::blocked_range<size_t>( 0, v11.size() ),
    Insert_in_CCC_functor<Vect, Cont>(v11, c11, iterators)
  );
  assert(c11.size() == v11.size());
  
  std::cout << "Testing parallel erasure" << std::endl;
  tbb::parallel_for(
    tbb::blocked_range<size_t>( 0, v11.size() ),
    Erase_in_CCC_functor<Cont>(c11, iterators)
  );
  assert(c11.empty());
  }

  std::cout << "Testing parallel insertion AND erasure" << std::endl;
  {
  Cont c12;
  Vect v12(1000000);
  std::vector<tbb::atomic<bool> > free_elements(v12.size());
  for(typename std::vector<tbb::atomic<bool> >::iterator 
    it = free_elements.begin(), end = free_elements.end(); it != end; ++it) 
  {
    *it = true;
  }
    
  tbb::atomic<unsigned int> num_erasures; 
  num_erasures = 0;
  std::vector<typename Cont::iterator> iterators(v12.size());
  tbb::parallel_for(
    tbb::blocked_range<size_t>( 0, v12.size() ),
    Insert_and_erase_in_CCC_functor<Vect, Cont>(
      v12, c12, iterators, free_elements, num_erasures)
  );
  assert(c12.size() == v12.size() - num_erasures);
  }
}