示例#1
0
文件: model.hpp 项目: nschloe/nosh
  Thyra::ModelEvaluatorBase::InArgs<double>
  init_nominal_values_(
      const std::shared_ptr<const Tpetra::Vector<double,int,int>> & x
      )
  {
    const auto f_params = f_->get_scalar_parameters();
    const auto jac_params = jac_->get_scalar_parameters();
    const auto dfdp_params = dfdp_->get_scalar_parameters();

    std::map<std::string, double> all_params;
    all_params.insert(f_params.begin(), f_params.end());
    all_params.insert(jac_params.begin(), jac_params.end());
    all_params.insert(dfdp_params.begin(), dfdp_params.end());

    auto p_init = Thyra::createMember(this->get_p_space(0));
    int k = 0;
    for (auto it = all_params.begin(); it != all_params.end(); ++it) {
      Thyra::set_ele(k, it->second, p_init());
      k++;
    }

    auto nominal_values = this->createInArgs();
    const Teuchos::RCP<const Tpetra::Vector<double,int,int>> initial_x =
      Teuchos::rcp(x);
    const auto xxx = Thyra::createConstVector(initial_x, space_);
    nominal_values.set_p(0, p_init);
    nominal_values.set_x(xxx);

    return nominal_values;
  }
示例#2
0
void librandom::BinomialRandomDev::set_status(const DictionaryDatum &d)
{
  double p_tmp;
  if (  updateValue<double>(d, "p", p_tmp) )
    set_p(p_tmp);

  long n_tmp;
  if (  updateValue<long>(d, "n", n_tmp) )
    set_n(n_tmp);
} 
示例#3
0
int mpx_test (int argc, const char **argv)
{
    int *p;

    set_p (p);
    rd (p, 0);
    rd (p, 99);

    return 0;
}
示例#4
0
static int get_impropers(t_atoms *atoms, t_hackblock hb[], t_param **improper,
                         gmx_bool bAllowMissing)
{
    t_rbondeds   *impropers;
    int           nimproper, i, j, k, start, ninc, nalloc;
    atom_id       ai[MAXATOMLIST];
    gmx_bool      bStop;

    ninc   = 500;
    nalloc = ninc;
    snew(*improper, nalloc);

    /* Add all the impropers from the residue database to the list. */
    nimproper = 0;
    start     = 0;
    if (hb != NULL)
    {
        for (i = 0; (i < atoms->nres); i++)
        {
            impropers = &hb[i].rb[ebtsIDIHS];
            for (j = 0; (j < impropers->nb); j++)
            {
                bStop = FALSE;
                for (k = 0; (k < 4) && !bStop; k++)
                {
                    ai[k] = search_atom(impropers->b[j].a[k], start,
                                        atoms,
                                        "improper", bAllowMissing);
                    if (ai[k] == NO_ATID)
                    {
                        bStop = TRUE;
                    }
                }
                if (!bStop)
                {
                    if (nimproper == nalloc)
                    {
                        nalloc += ninc;
                        srenew(*improper, nalloc);
                    }
                    /* Not broken out */
                    set_p(&((*improper)[nimproper]), ai, NULL, impropers->b[j].s);
                    nimproper++;
                }
            }
            while ((start < atoms->nr) && (atoms->atom[start].resind == i))
            {
                start++;
            }
        }
    }

    return nimproper;
}
示例#5
0
obj* LinkedList() {
    obj* self = Object();
    self->dealloc = dealloc;

    list* list = ll_create();
    set_p(self, "value", &list, sizeof(struct llist_*));

    bind(self, "push back", push_back);
    bind(self, "push front", push_front);

    bind_o(self, "back", back);
    bind_o(self, "front", front);

    return self;
}
示例#6
0
static int get_impropers(t_atoms *atoms,t_hackblock hb[],t_param **idih,
			 bool bMissing)
{
  char      *a0;
  t_rbondeds *idihs;
  t_rbonded  *hbidih;
  int       nidih,i,j,k,r,start,ninc,nalloc;
  atom_id   ai[MAXATOMLIST];
  bool      bStop;
  
  ninc = 500;
  nalloc = ninc;
  snew(*idih,nalloc);

  /* Add all the impropers from the residue database to the list. */
  nidih = 0;
  start = 0;
  if (hb != NULL) {
    for(i=0; (i<atoms->nres); i++) {
      idihs=&hb[i].rb[ebtsIDIHS];
      for(j=0; (j<idihs->nb); j++) {
	bStop=FALSE;
	for(k=0; (k<4) && !bStop; k++) {
	  ai[k] = search_atom(idihs->b[j].a[k],start,
			      atoms->nr,atoms->atom,atoms->atomname,
			      "improper",bMissing);
	  if (ai[k] == NO_ATID)
	    bStop = TRUE;
	}
	if (!bStop) {
	  if (nidih == nalloc) {
	    nalloc += ninc;
	    srenew(*idih,nalloc);
	  }
	  /* Not broken out */
	  set_p(&((*idih)[nidih]),ai,NULL,idihs->b[j].s);
	  nidih++;
	}
      }
      while ((start<atoms->nr) && (atoms->atom[start].resind == i))
	start++;
    }
  }
  
  return nidih;
}
示例#7
0
  Thyra::ModelEvaluatorBase::InArgs<double>
  init_nominal_values_(
      const Teuchos::RCP<const Tpetra::Vector<double,int,int>> & x,
      const double alpha0
      )
  {
    auto p_init = Thyra::createMember(this->get_p_space(0));
    Thyra::set_ele(0, alpha0, p_init());

    const auto xxx = Thyra::createConstVector(x, space_);

    auto nominal_values = this->createInArgs();
    nominal_values.set_p(0, p_init);
    nominal_values.set_x(xxx);

    return nominal_values;
  }
示例#8
0
int		main(void)
{
	char	*line;
	char	p[20];
	char	c;
	char	*co;
	t_game	*filler;

	c = 'p';
	line = NULL;
	get_next_line(0, &co);
	c = init_char(co);
	ft_strcpy(p, "5 11\n");
	while (get_next_line(0, &line))
		if (ft_strlen(line) > 0)
		{
			filler = get_data(c, line);
			set_p(p, filler);
			free_filler(&filler);
			write(1, p, ft_strlen(p));
		}
	return (0);
}
void
librandom::GSL_BinomialRandomDev::set_p_n( double p_s, unsigned n_s )
{
  set_p( p_s );
  set_n( n_s );
}
示例#10
0
int
main(void)
{
    mp_bitcnt_t bits;
    mp_size_t j, k, n, w, limbs, d;
    mp_limb_t * nn, * r;
    mpz_t p, m1, m2, mn1, mn2;

    gmp_randstate_t state;

    tests_start();
    fflush(stdout);

    gmp_randinit_default(state);

    mpz_init(m1);
    mpz_init(m2);
    mpz_init(mn1);
    mpz_init(mn2);
    mpz_init(p);

    /* normalisation mod p = 2^wn + 1 where B divides nw and n is a power of 2 */
    for (bits = GMP_LIMB_BITS; bits < 16*GMP_LIMB_BITS; bits += GMP_LIMB_BITS)
    {
        for (j = 1; j < 32; j++)
        {
            for (k = 1; k <= GMP_LIMB_BITS; k <<= 1)
            {
                for (d = 0; d < GMP_LIMB_BITS; d++)
                {
                    n = bits/k;
                    w = j*k;
                    limbs = (n*w)/GMP_LIMB_BITS;
            
                    nn = malloc((limbs + 1)*sizeof(mp_limb_t));
                    r  = malloc((limbs + 1)*sizeof(mp_limb_t));
                    mpir_random_fermat(nn, state, limbs);
                    mpir_fermat_to_mpz(mn1, nn, limbs);
                    set_p(p, n, w);
            
                    mpn_div_2expmod_2expp1(r, nn, limbs, d);
                    mpir_fermat_to_mpz(m2, r, limbs);
                    mpz_mod(m2, m2, p);
                    
                    mpz_mod(m1, mn1, p);
                    mpz_mul_2exp(m2, m2, d);
                    mpz_mod(m2, m2, p);
                    
                    if (mpz_cmp(m1, m2) != 0)
                    {
                        printf("FAIL:\n");
                        printf("mpn_div_2expmod_2expp1 error\n");
                        gmp_printf("want %Zx\n\n", m1);
                        gmp_printf("got  %Zx\n", m2);
                        abort();
                    }
                }

                free(nn);
                free(r);
            }
        }
    }

    mpz_clear(mn2);
    mpz_clear(mn1);
    mpz_clear(m2);
    mpz_clear(m1);
    mpz_clear(p);

    gmp_randclear(state);
    
    tests_end();
    return 0;
}
示例#11
0
int
main(void)
{
    mp_size_t c, bits, j, k, x, y, n, w, limbs;
    mpz_t p, ma, mb, m2a, m2b, mn1, mn2;
    mp_limb_t * nn1, * nn2, * r1, * r2;
   
    flint_rand_t state;

    printf("butterfly_rshB....");
    fflush(stdout);

    flint_randinit(state);
    _flint_rand_init_gmp(state);

    mpz_init(p);
    mpz_init(ma);
    mpz_init(mb);
    mpz_init(m2a);
    mpz_init(m2b);
    mpz_init(mn1);
    mpz_init(mn2);
   
    for (bits = FLINT_BITS; bits < 20*FLINT_BITS; bits += FLINT_BITS)
    {
        for (j = 1; j < 10; j++)
        {
            for (k = 1; k <= FLINT_BITS; k <<= 1)
            {
                n = bits/k;
                w = j*k;

                limbs = (n*w)/FLINT_BITS;

                for (c = 0; c < limbs; c++)
                {
                    x = n_randint(state, limbs);
                    y = n_randint(state, limbs);
                    
                    nn1 = flint_malloc((limbs + 1)*sizeof(mp_limb_t));
                    nn2 = flint_malloc((limbs + 1)*sizeof(mp_limb_t));
                    r1 = flint_malloc((limbs + 1)*sizeof(mp_limb_t));
                    r2 = flint_malloc((limbs + 1)*sizeof(mp_limb_t));
                    mpn_rrandom(nn1, state->gmp_state, limbs);
                    random_fermat(nn1, state, limbs);
                    random_fermat(nn2, state, limbs);
                     
                    fermat_to_mpz(mn1, nn1, limbs);
                    fermat_to_mpz(mn2, nn2, limbs);
                    set_p(p, n, w);
            
                    butterfly_rshB(r1, r2, nn1, nn2, limbs, x, y);
                    fermat_to_mpz(m2a, r1, limbs);
                    fermat_to_mpz(m2b, r2, limbs);
                    
                    mpz_mod(m2a, m2a, p);
                    mpz_mod(m2b, m2b, p);
                    ref_butterfly_rshB(ma, mb, mn1, mn2, p, x, y);

                    if (mpz_cmp(ma, m2a) != 0)
                    {
                        printf("FAIL:\n");
                        printf("butterfly_rshB error a\n");
                        printf("x = %ld, y = %ld, limbs = %ld\n", x, y, limbs);
                        printf("n = %ld, w = %ld, k = %ld, c = %ld\n", n, w, k, c);
                        gmp_printf("want %Zx\n\n", ma);
                        gmp_printf("got  %Zx\n", m2a);
                        abort();
                    }
                    if (mpz_cmp(mb, m2b) != 0)
                    {
                        printf("FAIL:\n");
                        printf("butterfly_rshB error b\n");
                        printf("x = %ld, y = %ld, limbs = %ld\n", x, y, limbs);
                        printf("n = %ld, w = %ld, k = %ld, c = %ld\n", n, w, k, c);
                        gmp_printf("want %Zx\n\n", mb);
                        gmp_printf("got  %Zx\n", m2b);
                        abort();
                    }
                    
                    flint_free(nn1);
                    flint_free(nn2);
                    flint_free(r1);
                    flint_free(r2);
                }
            }
        }
    }

    mpz_clear(p);
    mpz_clear(ma);
    mpz_clear(mb);
    mpz_clear(m2a);
    mpz_clear(m2b);
    mpz_clear(mn1);
    mpz_clear(mn2);

    flint_randclear(state);
    
    printf("PASS\n");
    return 0;
}
示例#12
0
int
main(void)
{
    mp_bitcnt_t bits;
    mp_size_t j, k, n, w, limbs;
    mp_limb_t * nn;
    mpz_t p, m1, m2;

    FLINT_TEST_INIT(state);

    flint_printf("normmod_2expp1....");
    fflush(stdout);

    
    _flint_rand_init_gmp(state);

    mpz_init(m1);
    mpz_init(m2);
    mpz_init(p);

    /* normalisation mod p = 2^wn + 1 where B divides nw and n is a power of 2 */
    for (bits = FLINT_BITS; bits < 32*FLINT_BITS; bits += FLINT_BITS)
    {
        for (j = 1; j < 32; j++)
        {
            for (k = 1; k <= GMP_NUMB_BITS; k <<= 1)
            {
                n = bits/k;
                w = j*k;
                limbs = (n*w)/GMP_LIMB_BITS;
            
                nn = flint_malloc((limbs + 1)*sizeof(mp_limb_t));
                random_fermat(nn, state, limbs);
                fermat_to_mpz(m1, nn, limbs);
                set_p(p, n, w);
            
                mpn_normmod_2expp1(nn, limbs);
                fermat_to_mpz(m2, nn, limbs);
                mpz_mod(m1, m1, p);

                if (mpz_cmp(m1, m2) != 0)
                {
                    flint_printf("FAIL:\n");
                    flint_printf("mpn_normmod_2expp1 error\n");
                    gmp_printf("want %Zx\n\n", m1);
                    gmp_printf("got  %Zx\n", m2);
                    abort();
                }

                flint_free(nn);
            }
        }
    }

    mpz_clear(m2);
    mpz_clear(m1);
    mpz_clear(p);

    FLINT_TEST_CLEANUP(state);
    
    flint_printf("PASS\n");
    return 0;
}
示例#13
0
// =============================================================================
void
testComputeF(
    const std::string & input_filename_base,
    const double mu,
    const double control_norm_1,
    const double control_norm_2,
    const double control_norm_inf
)
{
    // Read the data from the file.
    auto comm =  Teuchos::DefaultComm<int>::getComm();
    const int size = comm->getSize();
    const std::string input_filename = (size == 1) ?
                                       "data/" + input_filename_base + ".h5m" :
                                       "data/" + input_filename_base + "-" + std::to_string(size) + ".h5m"
                                       ;

    // Read the data from the file.
    auto mesh = nosh::read(input_filename);

    // Cast the data into something more accessible.
    auto z = mesh->get_complex_vector("psi");

    // Set the thickness field.
    auto thickness = std::make_shared<nosh::scalar_field::constant>(*mesh, 1.0);
    auto mvp = std::make_shared<nosh::vector_field::explicit_values>(*mesh, "A", mu);
    auto sp = std::make_shared<nosh::scalar_field::constant>(*mesh, -1.0);

    auto model_eval = Teuchos::rcp(new nosh::model_evaluator::nls(
                                       mesh,
                                       mvp,
                                       sp,
                                       1.0,
                                       thickness,
                                       z,
                                       "mu"
                                   ));

    // Create in_args.x
    auto in_args = model_eval->createInArgs();
    in_args.set_x(Thyra::createVector(Teuchos::rcp(z), model_eval->get_f_space()));
    // in_args.p
    auto p = Thyra::createMember(model_eval->get_p_space(0));
    Thyra::set_ele(0, 1.0, p()); // g
    Thyra::set_ele(1, 0.01, p()); // mu
    in_args.set_p(0, p);

    // Create out_args.
    auto out_args = model_eval->createOutArgs();
    auto f = Thyra::createMember(model_eval->get_f_space());
    out_args.set_f(f);

    // Fetch.
    model_eval->evalModel(in_args, out_args);

    // check the norms
    REQUIRE(Thyra::norm_1(*f) == Approx(control_norm_1));
    REQUIRE(Thyra::norm_2(*f) == Approx(control_norm_2));
    REQUIRE(Thyra::norm_inf(*f) == Approx(control_norm_inf));

    return;
}
示例#14
0
PauliChannel::PauliChannel(uint_t nq, rvector_t p_pauli) : n(nq) {
  set_p(p_pauli);
}