text:
Q: Passing delegate declaration to a class and then later changing its value to be invoked I want to pass a delegate declaration to a class that will later be assigned by a different class and then later invoked by the first class.  I get a NullReferenceException at the line indicated in the code below.  How can I change the code to get the desired behavior?
class FirstClass
    {
        public Func<bool> funct;

        public FirstClass(Func<bool> funct)
        {
            this.funct = funct;
        }

        public void callFunc()
        {
            funct.Invoke();  // NullReferenceException
        }
    }

    class Program
    {
        public static Func<bool> testFunction;

        static void Main(string[] args)
        {
            FirstClass firstClassInstance = new FirstClass(testFunction);

            var secondClassInstance = new SecondClass();

            firstClassInstance.callFunc();
        }
    }

    class SecondClass
    {
        public SecondClass()
        {
            Program.testFunction = isManipUnderCursor;
        }

        private bool isManipUnderCursor()
        {
            return true;
        }
    }

A: If you want to invoke whatever is the current value of Program.testFunction, invoke Program.testFunction
    public void callFunc()
    {
        Program.testFunction?.Invoke();
    }

Or you provide a code that changes the value of what FirstClass.funct is, and call that:
class FirstClass{
  ...
  public void ChangeFuncTo(Func<bool> newFunc){
    funct = newFunc;
  }
  ...
}

        FirstClass firstClassInstance = new FirstClass(testFunction);

        var secondClassInstance = new SecondClass();

        firstClassInstance.ChangeFuncTo(Program.funct);

This whole thing you've arranged is fairly terrible in terms of structure, encapsulation and coherent class responsibilities. It would be good if you could post an actual use case for what the true aim is, so we can advise, but in general you should treat funcs like data; if you only know what operation you want firstclass's func to perform after you have finished constructing and using some other object, don't rely on a static to pass the new func around; provide and call a method on the first class to set the new behavior. Strive to find ways of avoiding static in your code.
        //we need to make FirstClass for some reason, before we can generate the fun it will use
        FirstClass firstClassInstance = new FirstClass();

        //second class is a func generator
        var secondClassInstance = new SecondClass();

        //now we can generate the func and set it

firstClassInstance.ChangeFuncTo(secondClassInstance.GetNewFunc());
Or
        //second class is a func generator, it can generate before firstclass is made
        var secondClassInstance = new SecondClass();

        //now we can generate the func and set it
        FirstClass firstClassInstance = new FirstClass(secondClassInstance.GetFunc());

In C# you can't "change what some simple variable points to, by changing what some other simple variable points to". To explain it in simpler terms of good old data:
string first = "this is the first string";
string second = first
first = "something else";

second will still refer to that value of "this is the first string". When you establish extra references, they don't chain. When you write string first = "this is the first string"; it gives us memory like this:
first --> "this is the first string"

Then you write string second = first which gives us memory like this:
first --> "this is the first string" <-- second

Finally you write first = "something else" which gives us memory like:
          "this is the first string" <-- second

first --> "something else"

Changing first never affected second. When writing string second = first you don't end up with chained references in memory, like this:
second --> first --> "this is the first string"

such that altering first would cause second to see it:
second --> first --.    //"this is the first string" garbage collected
                    `-> "something else"

A: When you pass testFunction to FirstClass, it is null because testFunction has not been initialized or assigned. In this case, the reference passed doesn't point to the future home of the value, but it points to null and always will.


text:
Town & Village
Stuyvesant Town, Peter Cooper Village, Gramercy, Waterside
Around & About
Cutting Corners
Hurricane-impacted cats, dogs find owners at Adoptapalooza
Dena Spinelli, a volunteer with rescue organization Husky House with Jake, a now-healthy husky that was rescued from a puppy mill (Photos by Sabina Mollot)
By Sabina Mollot
On Sunday afternoon, over 400 cats and dogs in need of homes were brought to Union Square Park for Adoptapalooza, an event held by the Mayor's Alliance for NYC's Animals and the Petco Foundation. A constant stream of animal lovers, many considering adopting or fostering new pets, filled the park's north end, which was lined with booths manned by shelter volunteers as well as a few booths for games, pet photos and caricatures as well as a grass field.
Jane Hoffman, president of the Mayor's Alliance, said at Adoptapalooza events, it's typical for around 200 animals to get adopted.
"The value of it is it creates awareness," said Hoffman, who also said it's become a popular destination for families. This year, the event took on some extra urgency though thanks to a flurry of homeless pets from Florida and Texas following the hurricanes Irma and Harvey.
"When we had Superstorm Sandy, we had groups fly out of parts of the country and help us," Hoffman said. "With Harvey and Irma, our groups stepped up to help them."
Jane Hoffman, president of the Mayor's Alliance for NYC's Animals
What's been happening in a number of cases is shelters in hurricane-impacted areas have sent their charges to shelters in other regions so they can make room for local, now homeless or flooded out stray animals.
This hasn't come without its challenges though. In New York City, it's always harder to get larger dogs adopted as well as certain breeds like pit bulls, due to rules imposed by many landlords.
Hoffman said this was a shame, because she believes most dog owners would be willing to pay a deposit or bond to a building if it meant they could have their pet.
"It's unfair to stigmatize larger dogs," said Hoffman. "I'm all for reasonable regulations, like they must be vaccinated, microchipped and they need to go to a trainer. But just to ban them, that's not right."
A volunteer from Bideawee, Miryam Greene, said the organization tries to work around this by bringing their smaller dogs to Manhattan adoption events, and the bigger pooches to an event that takes place in Long Island. "We bring the bigger dogs where they might need a bigger home," said Greene, as she trotted out a medium-sized Australian cattle mix puppy named Lime.
Pooches run in a grass training field
At times, a few rescue groups and shelters operating out of trucks had long lines of people waiting to step inside to see their array of animals. One couple, hoping to adopt a dog, was waiting on a line 27 people long outside the North Shore Animal League truck. Viviana Velez and Benjamin Bowe, of Chelsea, said they had previously gotten a beagle at Adoptapalooza, which had been rescued after over seven years of breeding puppies at a puppy mill.
"She had never seen sunlight or grass. For the first month she didn't know what to do," said Velez. Fortunately, "she's happy now."
For her new dog, Velez would have liked to have gotten a pit bull. "But they're on the no list" at her building that also includes German shepherds. After that Velez had no preference for breed, though Bowe said if possible, he wanted a corgi.
This year, participating groups and agencies included the Department of Health, which was issuing dog licenses, NYC Animal Care & Control, Bideawee, City Critters, the Wild Bird Fund and dozens of smaller rescue groups like Rescuzilla and Best Bullies (a pitbull-focused group).
Many of those groups get their animals from NYCACC in order to keep animals from getting euthanized, which happens when those shelters get overcrowded. And because they must accept any animals that come through their doors, they get overcrowded a lot.
One of those smaller organizations is the Patricia Ladew Foundation, which shelters about 100 cats at given time. Dr. Susan Winttred, who runs the center, said most of the cats come from local city shelters, including after the recent hurricanes.
"I figure if everyone's taking from the hurricane (areas) no one's taking from New York," she explained.
Damien, a domesticated pigeon raised by Wild Bird Fund volunteers
At her booth, the organization's mascot cat, Rubio, was manning a kissing booth, while at the nearby Wild Bird Fund's booth, all eyes were on Damien, a pigeon raised by volunteer Chris Stub and his wife Wolfie. The couple had found it at four weeks old, emaciated. They then fostered the bird, which now prefers its human parents' company over that of other birds.
"It's like a feral cat or a dog. You can probably get it to like people," Chris Stub explained.
Another animal rescue organization, Linda's, also had a booth. Its founder, Linda Bryant, said she started the organization after moving to a neighborhood in Queens that was overrun with feral cats. The London native knew she wasn't the only one who thought it was a problem when she organized a meeting for neighbors and had 60 people show up.
"In London you don't see so many cats running around," she said. Out of 40 cats and kittens the organization had up for adoption on Sunday, when speaking with a reporter an hour into the event, Bryant said she'd already found new owners for all her kittens.
Rubio, mascot cat of the Patricia Ladew Foundation, is put on kissing duty
Meanwhile, Christine Hahny, a volunteer for NYCACC, said the organization gets about 35,000 animals in need of shelter a year. In a Manhattan shelter, there are typically 60 dogs and 100 cats at any given time. The organization gets some funding from the city but also fundraises. She said the event was great for getting animals adopted — even the bigger dogs.
While she agreed many landlords have rules against bigger dogs, "there are (also) a lot of places that don't discriminate against big dogs."
Dena Spinelli, a volunteer with the New Jersey-based Husky House, also cheered the event, mainly because it gets the dogs out of the kennel. The group specializes in hard to adopt dogs, like those with medical issues or that have come from hoarding cases. On Sunday, Spinelli was walking a husky, Jake, that had been rescued from an Amish puppy mill. Now, she said, "He's super healthy and loves belly rubs."
Another group at the event was The Wild Dog Foundation, with Frank Vincenti, its president, trying to spread awareness about coyotes migrating into the city. He believes this is due to recent, harsh winters. "A lot of young animals will leave to find new territory," he explained. "When winters are bad, you'll see a dispersal to Manhattan and Queens. They're already in the Bronx."
Vincenti strongly advised against trying to tame coyotes or turn them into pets. "Exotic animals don't make good pets," he said, adding, "Being here, you know there are plenty of other animals that need good homes."
Posted by Maria Rocha-Buschel in Dogs
Tagged: adoptapalooza, bideawee, hurricane harvey, mayor's animal alliance, Petco Foundation, Union Square
← Editorial: Rage against the Democratic machine
Redesigned dog run in the works for Madison Sq. Park →
Topics Select Category 13th Precinct (731) 14th Street Y (7) 17th precinct (4) 19th Precinct (1) 6th Precinct (7) 9th Precinct (46) Affordable housing (40) Bedpan Alley (46) Biking (2) Blackstone (48) Boy Scouts (1) Businesses (116) Cats (3) Community Board 6 (62) Community gardens (2) CompassRock (45) Con Ed (46) Construction/development (36) COVID-19 (19) Crime (646) CWCapital (106) Development (18) Dogs (43) East Midtown Plaza (2) East River (16) East Village (81) East Village community gardens (10) Editorial/Op-Ed/Opinion (292) Elections (5) Emergency Alert (52) Emergency Preparedness (16) Entertainment (112) environment (4) Events (153) Exhibits (9) Facebook (1) Fire (23) First Avenue (49) Flatiron (31) Flatiron BID (15) Flatiron District (43) Food (7) Good Shepherd Services (3) Gramercy (51) Gramercy Park (72) Greenmarket (4) history (4) Holidays (54) Homelessness (17) Hospitals (74) Houses of worship (10) Hurricane Sandy (48) Ivanhoe Cambridge (4) Just plain weird (2) Kips Bay (70) L train shutdown (60) Lawsuits/legal (4) Leasing (3) Legislation (28) Letters to the Editor (395) LGBT (6) Little League (12) local authors (2) Local Businesses (95) Local Historic Profile (1) Missing person (28) NYCHA (7) NYPD (30) Obituaries (15) Parks (67) Peter Cooper Village (228) Photography (1) Police Watch (253) Politics (445) Reader opinions (6) Real estate (19) Religion (4) Religious Institutions (7) Rent hikes (64) Rent Reg (103) Resident stories (1) Roberts v. Tishman speyer (44) Sanitation garage (21) Schools (31) Seniors (16) Snow (5) Soapbox (27) Sports (18) Squirrels (11) ST-PCV Tenants Association (96) ST/PCV ownership (85) Stuy Town after the war (3) Stuyvesant Town (499) Stuyvesant Town ownership (7) The Soapbox (7) This week in history (11) This Week in Pictures (40) Transportation (153) Uncategorized (25) Union Square (104) Veterans (6) Waterside Plaza (59) weather (1) Week In Review (5) wildlife (17)
Post Archives Select Month April 2020 (22) March 2020 (36) February 2020 (30) January 2020 (20) December 2019 (11) November 2019 (18) October 2019 (44) September 2019 (41) August 2019 (42) July 2019 (34) June 2019 (49) May 2019 (52) April 2019 (54) March 2019 (50) February 2019 (42) January 2019 (56) December 2018 (55) November 2018 (54) October 2018 (52) September 2018 (48) August 2018 (46) July 2018 (51) June 2018 (49) May 2018 (48) April 2018 (52) March 2018 (60) February 2018 (48) January 2018 (57) December 2017 (45) November 2017 (44) October 2017 (50) September 2017 (55) August 2017 (50) July 2017 (45) June 2017 (46) May 2017 (41) April 2017 (43) March 2017 (54) February 2017 (47) January 2017 (41) December 2016 (44) November 2016 (42) October 2016 (44) September 2016 (53) August 2016 (50) July 2016 (47) June 2016 (41) May 2016 (42) April 2016 (39) March 2016 (47) February 2016 (39) January 2016 (43) December 2015 (44) November 2015 (33) October 2015 (46) September 2015 (43) August 2015 (46) July 2015 (50) June 2015 (51) May 2015 (42) April 2015 (44) March 2015 (39) February 2015 (36) January 2015 (37) December 2014 (29) November 2014 (34) October 2014 (43) September 2014 (35) August 2014 (37) July 2014 (35) June 2014 (33) May 2014 (33) April 2014 (28) March 2014 (15) February 2014 (9) January 2014 (25) December 2013 (24) November 2013 (16) October 2013 (27) September 2013 (18) August 2013 (27) July 2013 (20) June 2013 (16) May 2013 (18) April 2013 (10) March 2013 (6) February 2013 (9) January 2013 (7) December 2012 (8) November 2012 (22) October 2012 (13) September 2012 (14) August 2012 (19) July 2012 (12) June 2012 (15) May 2012 (14) April 2012 (11) March 2012 (23) February 2012 (10) January 2012 (11) December 2011 (14) November 2011 (10) October 2011 (10) September 2011 (10) August 2011 (12) July 2011 (11) June 2011 (16) May 2011 (10)
Flatiron/23rd Street Partnership
Gramercy Neighborhood Associates
Gramercy Park Block Association
Madison Square Park Conservancy
Real Rent Reform Campaign
ST/PCV Tenants Association
Stuyvesant Park Neighborhood Association
Stuyvesant Square Community Alliance
Union Square BID
Union Square Community Coalition
13th Precinct Crime Stats
13th Precinct Twitter
Bedford and Bowery
Popular fruit cart reopens as council members call for COVID relief April 22, 2020
Original Stuy Town tenant Michael Wiley dies peacefully April 22, 2020
Maloney calls for action as postal service 'holds on for dear life' April 22, 2020
New School president donates $100,000 to help his students hurt by COVID April 22, 2020
Mayor says May Day rent strike will hurt more than help in corona virus recovery April 22, 2020
Frontline worker as residents to stop ignoring stay home orders April 22, 2020
New online workshop will help small businesses get COVID aid April 22, 2020
National Arts Club launches online program series April 22, 2020
Food for seniors program April 22, 2020
One woman makes big difference in community response to COVID April 22, 2020
Popular fruit cart reopens as council members call for COVID relief town-village.com/2020/04/22/pop… https://t.co/p1Hljv0peJ 9 months ago
Original Stuy Town tenant Michael Wiley dies peacefully town-village.com/2020/04/22/ori… https://t.co/eELf0gKv9S 9 months ago
Follow @TheTandV

redpajama_set_name: RedPajamaCommonCrawl


Call it magic, voodoo or just clutch play. Whatever the reason, Paramus Catholic continues to have the number of Don Bosco Prep, and as a result the Paladins are once again headed to MetLife Stadium.
Paramus Catholic defeated the Ironmen for the sixth consecutive time, this one a 35-29 victory in the Non-Public Group IV state finals. The Paladins survived a Hail Mary attempt at the end to hold on and advance to the state finals for the fourth time in five years.
This game featured a crazy second quarter that saw multiple momentum shifts and 44 total points scored. Paramus Catholic emerged with a 28-23 halftime lead.
The Paladins extended that margin late in the third quarter, only to see Don Bosco strike right back to cut the lead to six. The Ironmen had several possessions in the final period, but the Paramus Catholic defense came up with the critical stops.
Quarterback Andrew Brito made the Paramus Catholic offense go, rushing for 165 yards and passing for 149 and one touchdown. Alijah Jackson had 115 rushing yards and scored the first two touchdowns as the Paladins grabbed an early 14-0 lead.
Jonathan Clark added 50 rushing yards and two touchdowns. Javon Turner had 73 yards receiving, while Matthew Zelaya caught four passes for 59 yards and a score.
Freshman Jalen Berger had a big first half for Don Bosco, scoring twice as the Ironmen rallied to make it a game. Berger ended up with 13 carries for 170 yards.
Tommy DeVito completed 16-of-27 passes for 205 yards and one touchdown, a 53-yarder to Kevin Brennan. Brennan had 75 receiving yards and John McGuire added 50 yards on four catches.
Fourth-seeded Don Bosco also scored on defense, a 40-yard interception return by Gavin Sharkey.
The Ironmen finish at 6-5 after a strange football season that included three out-of-state defeats. The only New Jersey school to defeat Don Bosco was Paramus Catholic, which won both meetings.
Paramus Catholic, the top seed, improves to 9-2. The Paladins will meet third seed St. Peter's Prep in the Non-Public Group IV finals on Friday, December 2 at MetLife Stadium.
Those two teams played in both the 2013 and 2014 finals, with each side winning once. They also met earlier this season, with Paramus Catholic pulling out a win on a late touchdown.
For sports video highlights of this New Jersey high school state playoff football semifinal game, click play in the box at left.


text:
<?php
/**
 * Custom template tags for this theme.
 *
 * Eventually, some of the functionality here could be replaced by core features.
 *
 * @package llorix-one-lite
 */

if ( ! function_exists( 'llorix_one_lite_posts_navigation' ) ) :
/**
 * Display navigation to next/previous set of posts when applicable.
 *
 * @todo Remove this function when WordPress 4.3 is released.
 */
function llorix_one_lite_posts_navigation() {
		// Don't print empty markup if there's only one page.
		if ( $GLOBALS['wp_query']->max_num_pages < 2 ) {
			return;
			}
		?>

			<?php if ( get_next_posts_link() ) : ?>

<?php next_posts_link( esc_html__( 'Older posts', 'llorix-one-lite' ) ); ?>

			<?php endif; ?>

			<?php if ( get_previous_posts_link() ) : ?>

<?php previous_posts_link( esc_html__( 'Newer posts', 'llorix-one-lite' ) ); ?>

			<?php endif; ?>

		<?php
}
endif;

if ( ! function_exists( 'llorix_one_lite_posted_on' ) ) :
/**
 * Prints HTML with meta information for the current post-date/time and author.
 */
function llorix_one_lite_posted_on() {
		$time_string = '<time class="entry-date published updated" datetime="%1$s">%2$s</time>';
		if ( get_the_time( 'U' ) !== get_the_modified_time( 'U' ) ) {
			$time_string = '<time class="entry-date published" datetime="%1$s">%2$s</time><time class="updated" datetime="%3$s">%4$s</time>';
			}

		$time_string = sprintf(
		$time_string,
		esc_attr( get_the_date( 'c' ) ),
		esc_html( get_the_date() ),
		esc_attr( get_the_modified_date( 'c' ) ),
		esc_html( get_the_modified_date() )
			);

			$posted_on = sprintf( /* translators: %s is the date */
			_x( 'Posted on %s', 'post date', 'llorix-one-lite' ),
			'' . $time_string . ''
			);

			$byline = sprintf( /* translators: %s is the post author */
			_x( 'by %s', 'post author', 'llorix-one-lite' ),
			'' . esc_html( get_the_author() ) . ''
			);

			echo '' . $posted_on . ' ' . $byline . '';

}
endif;

if ( ! function_exists( 'llorix_one_lite_entry_footer' ) ) :
/**
 * Prints HTML with meta information for the categories, tags and comments.
 */
function llorix_one_lite_entry_footer() {
		// Hide category and tag text for pages.
		if ( 'post' == get_post_type() ) {
			/* translators: used between list items, there is a space after the comma */
			$categories_list = get_the_category_list( esc_html__( ', ', 'llorix-one-lite' ) );
			if ( $categories_list && llorix_one_lite_categorized_blog() ) {
				/* translators: %1$s is the categories list */
				printf( '' . esc_html__( 'Posted in %1$s', 'llorix-one-lite' ) . '', $categories_list );
			}

			/* translators: used between list items, there is a space after the comma */
			$tags_list = get_the_tag_list( '', esc_html__( ', ', 'llorix-one-lite' ) );
			if ( $tags_list ) {
				/* translators: %1$s is the tags list */
				printf( '' . esc_html__( 'Tagged %1$s', 'llorix-one-lite' ) . '', $tags_list );
			}
			}

		if ( ! is_single() && ! post_password_required() && ( comments_open() || get_comments_number() ) ) {
			echo '';
			comments_popup_link( esc_html__( 'Leave a comment', 'llorix-one-lite' ), esc_html__( '1 Comment', 'llorix-one-lite' ), esc_html__( '% Comments', 'llorix-one-lite' ) );
			echo '';
			}

		edit_post_link( esc_html__( 'Edit', 'llorix-one-lite' ), '', '' );
}
endif;

/**
 * Returns true if a blog has more than 1 category.
 *
 * @return bool
 */
function llorix_one_lite_categorized_blog() {
	$all_the_cool_cats = get_transient( 'llorix_one_lite_categories' );
	if ( false === $all_the_cool_cats ) {
		// Create an array of all the categories that are attached to posts.
		$all_the_cool_cats = get_categories(
			array(
				'fields'     => 'ids',
				'hide_empty' => 1,

				// We only need to know if there is more than one category.
				'number'     => 2,
			)
		);

		// Count the number of categories that are attached to the posts.
		$all_the_cool_cats = count( $all_the_cool_cats );

		set_transient( 'llorix_one_lite_categories', $all_the_cool_cats );
	}

	if ( $all_the_cool_cats > 1 ) {
		// This blog has more than 1 category so llorix_one_lite_categorized_blog should return true.
		return true;
	} else {
		// This blog has only 1 category so llorix_one_lite_categorized_blog should return false.
		return false;
	}
}

/**
 * Flush out the transients used in llorix_one_lite_categorized_blog.
 */
function llorix_one_lite_category_transient_flusher() {
	if ( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE ) {
		return;
	}
	// Like, beat it. Dig?
	delete_transient( 'llorix_one_lite_categories' );
}
add_action( 'edit_category', 'llorix_one_lite_category_transient_flusher' );
add_action( 'save_post', 'llorix_one_lite_category_transient_flusher' );

redpajama_set_name: RedPajamaGithub


text:
Q: OpenGL with C++: vtable troubles when passing class array to glTexImage2d I made a class Color with float r, float g, float b, float alpha. It has a base class with a virtual destructor.
I am trying to pass an array of Color to the opengl function glTexImage2D, with a GL_RGBA organization of type float (which would be an array of {float r, float g, float b, float alpha}). This requires Color to contain only 4 floats (size of 16 bytes).
However, sizeof(Color) reveals that my class has a size of 20 bytes due to the base class of Color having a vtable, thanks to the destructor.
How can I keep my vtable and still pass my Color array to glTexImage2D?

A: Some gl functions allow you to pass a stride along with the data pointer, which tells gl how many bytes it should increment the pointer to get to the next data element each time. You could pass a stride of sizeof(Color), and if you can find the offset within the structure layout to get to the floats... well that would be the only way to do this that I can see. However you would definitely need to make some changes. To force adjacent layout, you would have to make the floats all held in a float[4]...
Regardless, glTexImage2D doesn't actually have stride, so this is out the window.
I think the better question is, why does your color structure have a base class or a virtual destructor? Color data is not a resource, so this is likely breaking the rule of three / rule of five / rule of zero.
You might do better to make a simple, POD type for the color, and then whatever fancy stuff you have happening in the destructor, make a second class which contains a color POD, and also has the base class etc.

A: Short answer: No, you can't do that.
You can see all the extra parameters for glTexImage2D() in the glPixelStore() documentation.  As you can see, there are no parameters for adding a "stride" or "padding" between pixels.  There are options for adding space at the beginning or end of rows, or between images (3D), but nothing between pixels.
Advice: An array of identical 4D vectors with a vtable for each is a design smell.  It is a bad design.  Your color type, in order to be compatible with C, should be a standard layout type.  Note that in particular this means that you cannot use virtual functions.
If you really need a base type with a virtual destructor, create a wrapper type.

redpajama_set_name: RedPajamaStackExchange


text:
Paige Arielle McPherson (Abilene, 1 de octubre de 1990) es una deportista estadounidense que compite en taekwondo.

Participó en tres Juegos Olímpicos de Verano entre los años 2012 y 2020, obteniendo una medalla de bronce en la edición de Londres 2012 en la categoría de –67 kg. En los Juegos Panamericanos consiguió tres medallas entre los años 2011 y 2019.

Ganó dos medallas en el Campeonato Mundial de Taekwondo en los años 2015 y 2017, y cuatro medallas en el Campeonato Panamericano de Taekwondo entre los años 2008 y 2018.

Palmarés internacional

Referencias

Practicantes de taekwondo de Estados Unidos
Practicantes de taekwondo en los Juegos Olímpicos de Londres 2012
Practicantes de taekwondo en los Juegos Olímpicos de Río de Janeiro 2016
Practicantes de taekwondo en los Juegos Olímpicos de Tokio 2020
Medallistas olímpicos de taekwondo
Medallistas olímpicos de bronce de Estados Unidos
Medallistas olímpicos de bronce de Londres 2012
Deportistas en los Juegos Panamericanos de 2011
Deportistas de Estados Unidos en los Juegos Panamericanos de 2015
Deportistas de Estados Unidos en los Juegos Panamericanos de 2019
Deportistas de Dakota del Sur
Nacidos en Abilene (Texas)
Afroestadounidenses

redpajama_set_name: RedPajamaWikipedia


and how many different types of thread you keep at hand.
Reasons for organizing embroidery floss?
When you are ready to begin a new needlework project the first step may be to find, or buy, the threads you need. If you are not organized it can often take longer to search through your stash, than it would to go and buy new skeins.
Don't you also find that new skeins have much more appeal than the tangled remnants at the bottom of the box?
I felt that getting organized would also prevent me from buying duplicate skeins. In fact, when I started to sort out my colors I found I had 8 skeins of electric blue!
Do you only work at home or do you carry your work around with you?
Do you want your collection on show, or tidied away out of sight?
Do you want to keep everything for a project separate from your main collection?
How much room do you have to store your threads?
How easy will be it to find a particular color or type of thread?
Are all your threads packaged in the same manner; skeins or balls for example?
Organizing embroidery floss by number or colour?
You have choices to make here.
If you are a cross stitcher you may prefer to store your threads in manufacturers number order. For freestyle work you might keep similar colors together, irrespective of the number.
If you do hardanger embroidery it might make more sense to sort them by thickness instead.
So what products are available to you? Do you have to make a big investment when organizing embroidery floss and other threads?
Luckily, there are some cheap ways to do this, especially if you don't mind a bit of DIY. Let's look at some of the options.
My local needlework shop stores their floss in wall units with transparent fronted drawers. Although this might not be possible at home, a quick trip to your local DIY store may find something similar.
You are sure to find units designed for storing nails and screws which would work a treat!
My tip is to take some skeins with you so that you can try the units for size. The drawers need to be deep enough, front to back, for the skein to fit comfortably.
Cardboard dividers will keep different colors in each drawer separate.
Neat labels on the drawers, giving the colour numbers, make the threads easy to find.
The drawbacks arise if you do not have the whole collection of threads when you set up your system. Do you miss out the colour numbers that you do not have? Or do you have to reorganize the drawers later when you increase your stock?
Many people like to use a system of wrapping their floss onto numbered Plastic Floss Bobbins which are then stored in boxes with dividers inside.
You can also get cardboard bobbins, on which you can write the thread number. But these do tend to get worn and scruffy after a time, and then need replacing.
The Organizer Boxes are transparent allowing you to see the colour range without opening the box.
It is simple enough to add new threads to your collection. Just slot them in where they belong. When you remove a bobbin for a project, pop a placeholder card in its place. You can then jot down the name of the project, if you have more than one on the go at a time.
The Loran Cross Stitch Project Cards - are one of my favourite systems for getting organized.
Rectangles of stiff card have evenly-spaced holes punched down the right hand side. Each hole holds a skein of thread.
To attach the floss, first cut the skein into your ideal stitching length. Then fold the bundle in half and push the folded end through the hole, forming a loop. Pass the cut ends through the loop and pull firmly.
Write the colour number beside each hole as you go along, including all the colors in the range. You can add any that you are missing, later.
The left hand side of the cards have smaller holes so that you can place them in the binder.
Remove the amount of floss needed for your project and attach to a smaller card. This leaves the bulk of the thread in the original binder.
It is simple to remove just one length, for use, with the eye of your needle. Return any unused thread to the binder at the end of a project.
Another method of organizing embroidery floss is to use small plastic ziploc bags. Each bag holds one colour. Full skeins and leftover strands can be stored in the same bag. You can store the bags in boxes or baskets in either number or colour order. My friend Angie keeps all her blues in one basket and the greens in another for example.
The bag idea works well for project storage, also. Just thread the required bags onto the ring to carry around with you. Write the numbers on the bags with a permanent marker and you're set to go.
You might also want to consider the StitchBow Floss Holder for storing and organizing your threads.
I hope this introduction has given you some ideas for organizing embroidery floss. Now are you ready to start organizing the rest of your stash?


text:
package org.apache.calcite.plan.hep;

import org.apache.calcite.linq4j.function.Function2;
import org.apache.calcite.linq4j.function.Functions;
import org.apache.calcite.plan.AbstractRelOptPlanner;
import org.apache.calcite.plan.CommonRelSubExprRule;
import org.apache.calcite.plan.Context;
import org.apache.calcite.plan.RelDigest;
import org.apache.calcite.plan.RelOptCost;
import org.apache.calcite.plan.RelOptCostFactory;
import org.apache.calcite.plan.RelOptCostImpl;
import org.apache.calcite.plan.RelOptMaterialization;
import org.apache.calcite.plan.RelOptPlanner;
import org.apache.calcite.plan.RelOptRule;
import org.apache.calcite.plan.RelOptRuleOperand;
import org.apache.calcite.plan.RelTrait;
import org.apache.calcite.plan.RelTraitSet;
import org.apache.calcite.rel.RelNode;
import org.apache.calcite.rel.convert.Converter;
import org.apache.calcite.rel.convert.ConverterRule;
import org.apache.calcite.rel.convert.TraitMatchingRule;
import org.apache.calcite.rel.core.RelFactories;
import org.apache.calcite.rel.metadata.RelMdUtil;
import org.apache.calcite.rel.metadata.RelMetadataProvider;
import org.apache.calcite.rel.metadata.RelMetadataQuery;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.util.Pair;
import org.apache.calcite.util.Util;
import org.apache.calcite.util.graph.BreadthFirstIterator;
import org.apache.calcite.util.graph.CycleDetector;
import org.apache.calcite.util.graph.DefaultDirectedGraph;
import org.apache.calcite.util.graph.DefaultEdge;
import org.apache.calcite.util.graph.DepthFirstIterator;
import org.apache.calcite.util.graph.DirectedGraph;
import org.apache.calcite.util.graph.Graphs;
import org.apache.calcite.util.graph.TopologicalOrderIterator;

import com.google.common.collect.ImmutableList;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

/**
 * HepPlanner is a heuristic implementation of the {@link RelOptPlanner}
 * interface.
 */
public class HepPlanner extends AbstractRelOptPlanner {
  //~ Instance fields --------------------------------------------------------

  private final HepProgram mainProgram;

  private HepProgram currentProgram;

  private HepRelVertex root;

  private RelTraitSet requestedRootTraits;

  /**
   * {@link RelDataType} is represented with its field types as {@code List<RelDataType>}.
   * This enables to treat as equal projects that differ in expression names only.
   */
  private final Map<RelDigest, HepRelVertex> mapDigestToVertex =
      new HashMap<>();

  private int nTransformations;

  private int graphSizeLastGC;

  private int nTransformationsLastGC;

  private final boolean noDag;

  /**
   * Query graph, with edges directed from parent to child. This is a
   * single-rooted DAG, possibly with additional roots corresponding to
   * discarded plan fragments which remain to be garbage-collected.
   */
  private final DirectedGraph<HepRelVertex, DefaultEdge> graph =
      DefaultDirectedGraph.create();

  private final Function2<RelNode, RelNode, Void> onCopyHook;

  private final List<RelOptMaterialization> materializations =
      new ArrayList<>();

  //~ Constructors -----------------------------------------------------------

  /**
   * Creates a new HepPlanner that allows DAG.
   *
   * @param program program controlling rule application
   */
  public HepPlanner(HepProgram program) {
    this(program, null, false, null, RelOptCostImpl.FACTORY);
  }

  /**
   * Creates a new HepPlanner that allows DAG.
   *
   * @param program program controlling rule application
   * @param context to carry while planning
   */
  public HepPlanner(HepProgram program, Context context) {
    this(program, context, false, null, RelOptCostImpl.FACTORY);
  }

  /**
   * Creates a new HepPlanner with the option to keep the graph a
   * tree (noDag = true) or allow DAG (noDag = false).
   *
   * @param noDag      If false, create shared nodes if expressions are
   *                   identical
   * @param program    Program controlling rule application
   * @param onCopyHook Function to call when a node is copied
   */
  public HepPlanner(
      HepProgram program,
      Context context,
      boolean noDag,
      Function2<RelNode, RelNode, Void> onCopyHook,
      RelOptCostFactory costFactory) {
    super(costFactory, context);
    this.mainProgram = program;
    this.onCopyHook = Util.first(onCopyHook, Functions.ignore2());
    this.noDag = noDag;
  }

  //~ Methods ----------------------------------------------------------------

  // implement RelOptPlanner
  public void setRoot(RelNode rel) {
    root = addRelToGraph(rel);
    dumpGraph();
  }

  // implement RelOptPlanner
  public RelNode getRoot() {
    return root;
  }

  @Override public void clear() {
    super.clear();
    for (RelOptRule rule : getRules()) {
      removeRule(rule);
    }
    this.materializations.clear();
  }

  // implement RelOptPlanner
  public RelNode changeTraits(RelNode rel, RelTraitSet toTraits) {
    // Ignore traits, except for the root, where we remember
    // what the final conversion should be.
    if ((rel == root) || (rel == root.getCurrentRel())) {
      requestedRootTraits = toTraits;
    }
    return rel;
  }

  // implement RelOptPlanner
  public RelNode findBestExp() {
    assert root != null;

    executeProgram(mainProgram);

    // Get rid of everything except what's in the final plan.
    collectGarbage();
    dumpRuleAttemptsInfo();
    return buildFinalPlan(root);
  }

  private void executeProgram(HepProgram program) {
    HepProgram savedProgram = currentProgram;
    currentProgram = program;
    currentProgram.initialize(program == mainProgram);
    for (HepInstruction instruction : currentProgram.instructions) {
      instruction.execute(this);
      int delta = nTransformations - nTransformationsLastGC;
      if (delta > graphSizeLastGC) {
        // The number of transformations performed since the last
        // garbage collection is greater than the number of vertices in
        // the graph at that time.  That means there should be a
        // reasonable amount of garbage to collect now.  We do it this
        // way to amortize garbage collection cost over multiple
        // instructions, while keeping the highwater memory usage
        // proportional to the graph size.
        collectGarbage();
      }
    }
    currentProgram = savedProgram;
  }

  void executeInstruction(
      HepInstruction.MatchLimit instruction) {
    LOGGER.trace("Setting match limit to {}", instruction.limit);
    currentProgram.matchLimit = instruction.limit;
  }

  void executeInstruction(
      HepInstruction.MatchOrder instruction) {
    LOGGER.trace("Setting match order to {}", instruction.order);
    currentProgram.matchOrder = instruction.order;
  }

  void executeInstruction(
      HepInstruction.RuleInstance instruction) {
    if (skippingGroup()) {
      return;
    }
    if (instruction.rule == null) {
      assert instruction.ruleDescription != null;
      instruction.rule =
          getRuleByDescription(instruction.ruleDescription);
      LOGGER.trace("Looking up rule with description {}, found {}",
          instruction.ruleDescription, instruction.rule);
    }
    if (instruction.rule != null) {
      applyRules(
          Collections.singleton(instruction.rule),
          true);
    }
  }

  void executeInstruction(
      HepInstruction.RuleClass<?> instruction) {
    if (skippingGroup()) {
      return;
    }
    LOGGER.trace("Applying rule class {}", instruction.ruleClass);
    if (instruction.ruleSet == null) {
      instruction.ruleSet = new LinkedHashSet<>();
      for (RelOptRule rule : mapDescToRule.values()) {
        if (instruction.ruleClass.isInstance(rule)) {
          instruction.ruleSet.add(rule);
        }
      }
    }
    applyRules(instruction.ruleSet, true);
  }

  void executeInstruction(
      HepInstruction.RuleCollection instruction) {
    if (skippingGroup()) {
      return;
    }
    applyRules(instruction.rules, true);
  }

  private boolean skippingGroup() {
    if (currentProgram.group != null) {
      // Skip if we've already collected the ruleset.
      return !currentProgram.group.collecting;
    } else {
      // Not grouping.
      return false;
    }
  }

  void executeInstruction(
      HepInstruction.ConverterRules instruction) {
    assert currentProgram.group == null;
    if (instruction.ruleSet == null) {
      instruction.ruleSet = new LinkedHashSet<>();
      for (RelOptRule rule : mapDescToRule.values()) {
        if (!(rule instanceof ConverterRule)) {
          continue;
        }
        ConverterRule converter = (ConverterRule) rule;
        if (converter.isGuaranteed() != instruction.guaranteed) {
          continue;
        }

        // Add the rule itself to work top-down
        instruction.ruleSet.add(converter);
        if (!instruction.guaranteed) {
          // Add a TraitMatchingRule to work bottom-up
          instruction.ruleSet.add(
              TraitMatchingRule.config(converter, RelFactories.LOGICAL_BUILDER)
                  .toRule());
        }
      }
    }
    applyRules(instruction.ruleSet, instruction.guaranteed);
  }

  void executeInstruction(HepInstruction.CommonRelSubExprRules instruction) {
    assert currentProgram.group == null;
    if (instruction.ruleSet == null) {
      instruction.ruleSet = new LinkedHashSet<>();
      for (RelOptRule rule : mapDescToRule.values()) {
        if (!(rule instanceof CommonRelSubExprRule)) {
          continue;
        }
        instruction.ruleSet.add(rule);
      }
    }
    applyRules(instruction.ruleSet, true);
  }

  void executeInstruction(
      HepInstruction.Subprogram instruction) {
    LOGGER.trace("Entering subprogram");
    for (;;) {
      int nTransformationsBefore = nTransformations;
      executeProgram(instruction.subprogram);
      if (nTransformations == nTransformationsBefore) {
        // Nothing happened this time around.
        break;
      }
    }
    LOGGER.trace("Leaving subprogram");
  }

  void executeInstruction(
      HepInstruction.BeginGroup instruction) {
    assert currentProgram.group == null;
    currentProgram.group = instruction.endGroup;
    LOGGER.trace("Entering group");
  }

  void executeInstruction(
      HepInstruction.EndGroup instruction) {
    assert currentProgram.group == instruction;
    currentProgram.group = null;
    instruction.collecting = false;
    applyRules(instruction.ruleSet, true);
    LOGGER.trace("Leaving group");
  }

  private int depthFirstApply(Iterator<HepRelVertex> iter,
      Collection<RelOptRule> rules,
      boolean forceConversions, int nMatches) {
    while (iter.hasNext()) {
      HepRelVertex vertex = iter.next();
      for (RelOptRule rule : rules) {
        HepRelVertex newVertex =
            applyRule(rule, vertex, forceConversions);
        if (newVertex == null || newVertex == vertex) {
          continue;
        }
        ++nMatches;
        if (nMatches >= currentProgram.matchLimit) {
          return nMatches;
        }
        // To the extent possible, pick up where we left
        // off; have to create a new iterator because old
        // one was invalidated by transformation.
        Iterator<HepRelVertex> depthIter = getGraphIterator(newVertex);
        nMatches = depthFirstApply(depthIter, rules, forceConversions,
            nMatches);
        break;
      }
    }
    return nMatches;
  }

  private void applyRules(
      Collection<RelOptRule> rules,
      boolean forceConversions) {
    if (currentProgram.group != null) {
      assert currentProgram.group.collecting;
      currentProgram.group.ruleSet.addAll(rules);
      return;
    }

    LOGGER.trace("Applying rule set {}", rules);

    boolean fullRestartAfterTransformation =
        currentProgram.matchOrder != HepMatchOrder.ARBITRARY
        && currentProgram.matchOrder != HepMatchOrder.DEPTH_FIRST;

    int nMatches = 0;

    boolean fixedPoint;
    do {
      Iterator<HepRelVertex> iter = getGraphIterator(root);
      fixedPoint = true;
      while (iter.hasNext()) {
        HepRelVertex vertex = iter.next();
        for (RelOptRule rule : rules) {
          HepRelVertex newVertex =
              applyRule(rule, vertex, forceConversions);
          if (newVertex == null || newVertex == vertex) {
            continue;
          }
          ++nMatches;
          if (nMatches >= currentProgram.matchLimit) {
            return;
          }
          if (fullRestartAfterTransformation) {
            iter = getGraphIterator(root);
          } else {
            // To the extent possible, pick up where we left
            // off; have to create a new iterator because old
            // one was invalidated by transformation.
            iter = getGraphIterator(newVertex);
            if (currentProgram.matchOrder == HepMatchOrder.DEPTH_FIRST) {
              nMatches =
                  depthFirstApply(iter, rules, forceConversions, nMatches);
              if (nMatches >= currentProgram.matchLimit) {
                return;
              }
            }
            // Remember to go around again since we're
            // skipping some stuff.
            fixedPoint = false;
          }
          break;
        }
      }
    } while (!fixedPoint);
  }

  private Iterator<HepRelVertex> getGraphIterator(HepRelVertex start) {
    // Make sure there's no garbage, because topological sort
    // doesn't start from a specific root, and rules can't
    // deal with firing on garbage.

    // FIXME jvs 25-Sept-2006:  I had to move this earlier because
    // of FRG-215, which is still under investigation.  Once we
    // figure that one out, move down to location below for
    // better optimizer performance.
    collectGarbage();

    switch (currentProgram.matchOrder) {
    case ARBITRARY:
    case DEPTH_FIRST:
      return DepthFirstIterator.of(graph, start).iterator();

    case TOP_DOWN:
      assert start == root;
      // see above
/*
        collectGarbage();
*/
      return TopologicalOrderIterator.of(graph).iterator();

    case BOTTOM_UP:
    default:
      assert start == root;

      // see above
/*
        collectGarbage();
*/

      // TODO jvs 4-Apr-2006:  enhance TopologicalOrderIterator
      // to support reverse walk.
      final List<HepRelVertex> list = new ArrayList<>();
      for (HepRelVertex vertex : TopologicalOrderIterator.of(graph)) {
        list.add(vertex);
      }
      Collections.reverse(list);
      return list.iterator();
    }
  }

  private HepRelVertex applyRule(
      RelOptRule rule,
      HepRelVertex vertex,
      boolean forceConversions) {
    if (!graph.vertexSet().contains(vertex)) {
      return null;
    }
    RelTrait parentTrait = null;
    List<RelNode> parents = null;
    if (rule instanceof ConverterRule) {
      // Guaranteed converter rules require special casing to make sure
      // they only fire where actually needed, otherwise they tend to
      // fire to infinity and beyond.
      ConverterRule converterRule = (ConverterRule) rule;
      if (converterRule.isGuaranteed() || !forceConversions) {
        if (!doesConverterApply(converterRule, vertex)) {
          return null;
        }
        parentTrait = converterRule.getOutTrait();
      }
    } else if (rule instanceof CommonRelSubExprRule) {
      // Only fire CommonRelSubExprRules if the vertex is a common
      // subexpression.
      List<HepRelVertex> parentVertices = getVertexParents(vertex);
      if (parentVertices.size() < 2) {
        return null;
      }
      parents = new ArrayList<>();
      for (HepRelVertex pVertex : parentVertices) {
        parents.add(pVertex.getCurrentRel());
      }
    }

    final List<RelNode> bindings = new ArrayList<>();
    final Map<RelNode, List<RelNode>> nodeChildren = new HashMap<>();
    boolean match =
        matchOperands(
            rule.getOperand(),
            vertex.getCurrentRel(),
            bindings,
            nodeChildren);

    if (!match) {
      return null;
    }

    HepRuleCall call =
        new HepRuleCall(
            this,
            rule.getOperand(),
            bindings.toArray(new RelNode[0]),
            nodeChildren,
            parents);

    // Allow the rule to apply its own side-conditions.
    if (!rule.matches(call)) {
      return null;
    }

    fireRule(call);

    if (!call.getResults().isEmpty()) {
      return applyTransformationResults(
          vertex,
          call,
          parentTrait);
    }

    return null;
  }

  private boolean doesConverterApply(
      ConverterRule converterRule,
      HepRelVertex vertex) {
    RelTrait outTrait = converterRule.getOutTrait();
    List<HepRelVertex> parents = Graphs.predecessorListOf(graph, vertex);
    for (HepRelVertex parent : parents) {
      RelNode parentRel = parent.getCurrentRel();
      if (parentRel instanceof Converter) {
        // We don't support converter chains.
        continue;
      }
      if (parentRel.getTraitSet().contains(outTrait)) {
        // This parent wants the traits produced by the converter.
        return true;
      }
    }
    return (vertex == root)
        && (requestedRootTraits != null)
        && requestedRootTraits.contains(outTrait);
  }

  /**
   * Retrieves the parent vertices of a vertex.  If a vertex appears multiple
   * times as an input into a parent, then that counts as multiple parents,
   * one per input reference.
   *
   * @param vertex the vertex
   * @return the list of parents for the vertex
   */
  private List<HepRelVertex> getVertexParents(HepRelVertex vertex) {
    final List<HepRelVertex> parents = new ArrayList<>();
    final List<HepRelVertex> parentVertices =
        Graphs.predecessorListOf(graph, vertex);

    for (HepRelVertex pVertex : parentVertices) {
      RelNode parent = pVertex.getCurrentRel();
      for (int i = 0; i < parent.getInputs().size(); i++) {
        HepRelVertex child = (HepRelVertex) parent.getInputs().get(i);
        if (child == vertex) {
          parents.add(pVertex);
        }
      }
    }
    return parents;
  }

  private boolean matchOperands(
      RelOptRuleOperand operand,
      RelNode rel,
      List<RelNode> bindings,
      Map<RelNode, List<RelNode>> nodeChildren) {
    if (!operand.matches(rel)) {
      return false;
    }
    for (RelNode input : rel.getInputs()) {
      if (!(input instanceof HepRelVertex)) {
        // The graph could be partially optimized for materialized view. In that
        // case, the input would be a RelNode and shouldn't be matched again here.
        return false;
      }
    }
    bindings.add(rel);
    @SuppressWarnings("unchecked")
    List<HepRelVertex> childRels = (List) rel.getInputs();
    switch (operand.childPolicy) {
    case ANY:
      return true;
    case UNORDERED:
      // For each operand, at least one child must match. If
      // matchAnyChildren, usually there's just one operand.
      for (RelOptRuleOperand childOperand : operand.getChildOperands()) {
        boolean match = false;
        for (HepRelVertex childRel : childRels) {
          match =
              matchOperands(
                  childOperand,
                  childRel.getCurrentRel(),
                  bindings,
                  nodeChildren);
          if (match) {
            break;
          }
        }
        if (!match) {
          return false;
        }
      }
      final List<RelNode> children = new ArrayList<>(childRels.size());
      for (HepRelVertex childRel : childRels) {
        children.add(childRel.getCurrentRel());
      }
      nodeChildren.put(rel, children);
      return true;
    default:
      int n = operand.getChildOperands().size();
      if (childRels.size() < n) {
        return false;
      }
      for (Pair<HepRelVertex, RelOptRuleOperand> pair
          : Pair.zip(childRels, operand.getChildOperands())) {
        boolean match =
            matchOperands(
                pair.right,
                pair.left.getCurrentRel(),
                bindings,
                nodeChildren);
        if (!match) {
          return false;
        }
      }
      return true;
    }
  }

  private HepRelVertex applyTransformationResults(
      HepRelVertex vertex,
      HepRuleCall call,
      RelTrait parentTrait) {
    // TODO jvs 5-Apr-2006:  Take the one that gives the best
    // global cost rather than the best local cost.  That requires
    // "tentative" graph edits.

    assert !call.getResults().isEmpty();

    RelNode bestRel = null;

    if (call.getResults().size() == 1) {
      // No costing required; skip it to minimize the chance of hitting
      // rels without cost information.
      bestRel = call.getResults().get(0);
    } else {
      RelOptCost bestCost = null;
      final RelMetadataQuery mq = call.getMetadataQuery();
      for (RelNode rel : call.getResults()) {
        RelOptCost thisCost = getCost(rel, mq);
        if (LOGGER.isTraceEnabled()) {
          // Keep in the isTraceEnabled for the getRowCount method call
          LOGGER.trace("considering {} with cumulative cost={} and rowcount={}",
              rel, thisCost, mq.getRowCount(rel));
        }
        if ((bestRel == null) || thisCost.isLt(bestCost)) {
          bestRel = rel;
          bestCost = thisCost;
        }
      }
    }

    ++nTransformations;
    notifyTransformation(
        call,
        bestRel,
        true);

    // Before we add the result, make a copy of the list of vertex's
    // parents.  We'll need this later during contraction so that
    // we only update the existing parents, not the new parents
    // (otherwise loops can result).  Also take care of filtering
    // out parents by traits in case we're dealing with a converter rule.
    final List<HepRelVertex> allParents =
        Graphs.predecessorListOf(graph, vertex);
    final List<HepRelVertex> parents = new ArrayList<>();
    for (HepRelVertex parent : allParents) {
      if (parentTrait != null) {
        RelNode parentRel = parent.getCurrentRel();
        if (parentRel instanceof Converter) {
          // We don't support automatically chaining conversions.
          // Treating a converter as a candidate parent here
          // can cause the "iParentMatch" check below to
          // throw away a new converter needed in
          // the multi-parent DAG case.
          continue;
        }
        if (!parentRel.getTraitSet().contains(parentTrait)) {
          // This parent does not want the converted result.
          continue;
        }
      }
      parents.add(parent);
    }

    HepRelVertex newVertex = addRelToGraph(bestRel);

    // There's a chance that newVertex is the same as one
    // of the parents due to common subexpression recognition
    // (e.g. the LogicalProject added by JoinCommuteRule).  In that
    // case, treat the transformation as a nop to avoid
    // creating a loop.
    int iParentMatch = parents.indexOf(newVertex);
    if (iParentMatch != -1) {
      newVertex = parents.get(iParentMatch);
    } else {
      contractVertices(newVertex, vertex, parents);
    }

    if (getListener() != null) {
      // Assume listener doesn't want to see garbage.
      collectGarbage();
    }

    notifyTransformation(
        call,
        bestRel,
        false);

    dumpGraph();

    return newVertex;
  }

  // implement RelOptPlanner
  public RelNode register(
      RelNode rel,
      RelNode equivRel) {
    // Ignore; this call is mostly to tell Volcano how to avoid
    // infinite loops.
    return rel;
  }

  @Override public void onCopy(RelNode rel, RelNode newRel) {
    onCopyHook.apply(rel, newRel);
  }

  // implement RelOptPlanner
  public RelNode ensureRegistered(RelNode rel, RelNode equivRel) {
    return rel;
  }

  // implement RelOptPlanner
  public boolean isRegistered(RelNode rel) {
    return true;
  }

  private HepRelVertex addRelToGraph(
      RelNode rel) {
    // Check if a transformation already produced a reference
    // to an existing vertex.
    if (graph.vertexSet().contains(rel)) {
      return (HepRelVertex) rel;
    }

    // Recursively add children, replacing this rel's inputs
    // with corresponding child vertices.
    final List<RelNode> inputs = rel.getInputs();
    final List<RelNode> newInputs = new ArrayList<>();
    for (RelNode input1 : inputs) {
      HepRelVertex childVertex = addRelToGraph(input1);
      newInputs.add(childVertex);
    }

    if (!Util.equalShallow(inputs, newInputs)) {
      RelNode oldRel = rel;
      rel = rel.copy(rel.getTraitSet(), newInputs);
      onCopy(oldRel, rel);
    }
    // Compute digest first time we add to DAG,
    // otherwise can't get equivVertex for common sub-expression
    rel.recomputeDigest();

    // try to find equivalent rel only if DAG is allowed
    if (!noDag) {
      // Now, check if an equivalent vertex already exists in graph.
      HepRelVertex equivVertex = mapDigestToVertex.get(rel.getRelDigest());
      if (equivVertex != null) {
        // Use existing vertex.
        return equivVertex;
      }
    }

    // No equivalence:  create a new vertex to represent this rel.
    HepRelVertex newVertex = new HepRelVertex(rel);
    graph.addVertex(newVertex);
    updateVertex(newVertex, rel);

    for (RelNode input : rel.getInputs()) {
      graph.addEdge(newVertex, (HepRelVertex) input);
    }

    nTransformations++;
    return newVertex;
  }

  private void contractVertices(
      HepRelVertex preservedVertex,
      HepRelVertex discardedVertex,
      List<HepRelVertex> parents) {
    if (preservedVertex == discardedVertex) {
      // Nop.
      return;
    }

    RelNode rel = preservedVertex.getCurrentRel();
    updateVertex(preservedVertex, rel);

    // Update specified parents of discardedVertex.
    for (HepRelVertex parent : parents) {
      RelNode parentRel = parent.getCurrentRel();
      List<RelNode> inputs = parentRel.getInputs();
      for (int i = 0; i < inputs.size(); ++i) {
        RelNode child = inputs.get(i);
        if (child != discardedVertex) {
          continue;
        }
        parentRel.replaceInput(i, preservedVertex);
      }
      clearCache(parent);
      graph.removeEdge(parent, discardedVertex);
      graph.addEdge(parent, preservedVertex);
      updateVertex(parent, parentRel);
    }

    // NOTE:  we don't actually do graph.removeVertex(discardedVertex),
    // because it might still be reachable from preservedVertex.
    // Leave that job for garbage collection.

    if (discardedVertex == root) {
      root = preservedVertex;
    }
  }

  /**
   * Clears metadata cache for the RelNode and its ancestors.
   *
   * @param vertex relnode
   */
  private void clearCache(HepRelVertex vertex) {
    RelMdUtil.clearCache(vertex.getCurrentRel());
    if (!RelMdUtil.clearCache(vertex)) {
      return;
    }
    Queue<DefaultEdge> queue =
        new LinkedList<>(graph.getInwardEdges(vertex));
    while (!queue.isEmpty()) {
      DefaultEdge edge = queue.remove();
      HepRelVertex source = (HepRelVertex) edge.source;
      RelMdUtil.clearCache(source.getCurrentRel());
      if (RelMdUtil.clearCache(source)) {
        queue.addAll(graph.getInwardEdges(source));
      }
    }
  }

  private void updateVertex(HepRelVertex vertex, RelNode rel) {
    if (rel != vertex.getCurrentRel()) {
      // REVIEW jvs 5-Apr-2006:  We'll do this again later
      // during garbage collection.  Or we could get rid
      // of mark/sweep garbage collection and do it precisely
      // at this point by walking down to all rels which are only
      // reachable from here.
      notifyDiscard(vertex.getCurrentRel());
    }
    RelDigest oldKey = vertex.getCurrentRel().getRelDigest();
    if (mapDigestToVertex.get(oldKey) == vertex) {
      mapDigestToVertex.remove(oldKey);
    }
    // When a transformation happened in one rule apply, support
    // vertex2 replace vertex1, but the current relNode of
    // vertex1 and vertex2 is same,
    // then the digest is also same. but we can't remove vertex2,
    // otherwise the digest will be removed wrongly in the mapDigestToVertex
    //  when collectGC
    // so it must update the digest that map to vertex
    mapDigestToVertex.put(rel.getRelDigest(), vertex);
    if (rel != vertex.getCurrentRel()) {
      vertex.replaceRel(rel);
    }
    notifyEquivalence(
        rel,
        vertex,
        false);
  }

  private RelNode buildFinalPlan(HepRelVertex vertex) {
    RelNode rel = vertex.getCurrentRel();

    notifyChosen(rel);

    // Recursively process children, replacing this rel's inputs
    // with corresponding child rels.
    List<RelNode> inputs = rel.getInputs();
    for (int i = 0; i < inputs.size(); ++i) {
      RelNode child = inputs.get(i);
      if (!(child instanceof HepRelVertex)) {
        // Already replaced.
        continue;
      }
      child = buildFinalPlan((HepRelVertex) child);
      rel.replaceInput(i, child);
    }
    RelMdUtil.clearCache(rel);
    rel.recomputeDigest();

    return rel;
  }

  private void collectGarbage() {
    if (nTransformations == nTransformationsLastGC) {
      // No modifications have taken place since the last gc,
      // so there can't be any garbage.
      return;
    }
    nTransformationsLastGC = nTransformations;

    LOGGER.trace("collecting garbage");

    // Yer basic mark-and-sweep.
    final Set<HepRelVertex> rootSet = new HashSet<>();
    if (graph.vertexSet().contains(root)) {
      BreadthFirstIterator.reachable(rootSet, graph, root);
    }

    if (rootSet.size() == graph.vertexSet().size()) {
      // Everything is reachable:  no garbage to collect.
      return;
    }
    final Set<HepRelVertex> sweepSet = new HashSet<>();
    for (HepRelVertex vertex : graph.vertexSet()) {
      if (!rootSet.contains(vertex)) {
        sweepSet.add(vertex);
        RelNode rel = vertex.getCurrentRel();
        notifyDiscard(rel);
      }
    }
    assert !sweepSet.isEmpty();
    graph.removeAllVertices(sweepSet);
    graphSizeLastGC = graph.vertexSet().size();

    // Clean up digest map too.
    Iterator<Map.Entry<RelDigest, HepRelVertex>> digestIter =
        mapDigestToVertex.entrySet().iterator();
    while (digestIter.hasNext()) {
      HepRelVertex vertex = digestIter.next().getValue();
      if (sweepSet.contains(vertex)) {
        digestIter.remove();
      }
    }
  }

  private void assertNoCycles() {
    // Verify that the graph is acyclic.
    final CycleDetector<HepRelVertex, DefaultEdge> cycleDetector =
        new CycleDetector<>(graph);
    Set<HepRelVertex> cyclicVertices = cycleDetector.findCycles();
    if (cyclicVertices.isEmpty()) {
      return;
    }

    throw new AssertionError("Query graph cycle detected in HepPlanner: "
        + cyclicVertices);
  }

  private void dumpGraph() {
    if (!LOGGER.isTraceEnabled()) {
      return;
    }

    assertNoCycles();

    final RelMetadataQuery mq = root.getCluster().getMetadataQuery();
    final StringBuilder sb = new StringBuilder();
    sb.append("\nBreadth-first from root:  {\n");
    for (HepRelVertex vertex : BreadthFirstIterator.of(graph, root)) {
      sb.append("    ")
          .append(vertex)
          .append(" = ");
      RelNode rel = vertex.getCurrentRel();
      sb.append(rel)
          .append(", rowcount=")
          .append(mq.getRowCount(rel))
          .append(", cumulative cost=")
          .append(getCost(rel, mq))
          .append('\n');
    }
    sb.append("}");
    LOGGER.trace(sb.toString());
  }

  // implement RelOptPlanner
  public void registerMetadataProviders(List<RelMetadataProvider> list) {
    list.add(0, new HepRelMetadataProvider());
  }

  // implement RelOptPlanner
  public long getRelMetadataTimestamp(RelNode rel) {
    // TODO jvs 20-Apr-2006: This is overly conservative.  Better would be
    // to keep a timestamp per HepRelVertex, and update only affected
    // vertices and all ancestors on each transformation.
    return nTransformations;
  }

  @Override public ImmutableList<RelOptMaterialization> getMaterializations() {
    return ImmutableList.copyOf(materializations);
  }

  @Override public void addMaterialization(RelOptMaterialization materialization) {
    materializations.add(materialization);
  }
}


Fast, free delivery and low prices across a huge squash bags range. Same day despatch and next day delivery is available on all orders placed before 5pm.
We have a range of different sized bags from top brands including Head, Wilson, Dunlop, Tecnifibre and more.


text:
Q: Como puedo acceder a una lista generica desde otra clase en c# Hola como podria acceder a los valores de la lista desde otra clase en c#?
tengo el siguiente codigo
        class CLASE1
        {

            private string nombre;
            private string correo;

            List<string> lista=new list<string>();

            public void setNombre(string prmNombre)
                   {nombre = prmNombre;}

                   public string getNombre()
                   {return nombre;}

                   public void setCorreo(string prmCorreo)
                   {correo = prmCorreo;}

                  public string getCorreo()
                  {return correo;}

         public void agregar datos()
         {
           Console.ReadLine();
           lista.Add(getNombre());
           Console.ReadLine();
           lista.Add(getCorreo());
         }

     }

y tengo este codigo en la clase 2 a la que quiero acceder a los datos de la lista
class CLASE2
  {
     CLASE1 obj =new CLASE1();

 }

No se como podria acceder a los datos de mi lista, he intentado con el objeto que cree en la clase 2, pero me devuelve la lista sin valores adentro. gracias espero puedan ayudarme

A: Agrego código comentado en los lugares que considero son más relevantes, adaptado a C#:
class Program
{
    static void Main(string[] args)
    {
        Clase1 clase = new Clase1();
        clase.AgregarDatos();

        foreach(var s in clase.Lista){
            Console.WriteLine(s);
        }

    }
}

class Clase1{

    /*
    En C# el código:

    private string nombre;

    public void setNombre(string nombre){
        this.nombre = nombre;
    }

    public string getNombre(){
        return this.nombre;
    }

    puede reemplazarse por:

    public string Nombre {get;set;}
    */
    public string Nombre {get;set;}
    public string Correo {get;set;}

    // lista de tipo tupla (string,string) para guardar nombre y correo,
    // al no colocarle public por defecto era privada y por ese motivo
    // no lo veias al instanciar la clase1 desde la clase2.
    public List<(string,string)> Lista {get;set;}

    public Clase1(){
        Lista = new List<(string,string)>();
    }

    public void AgregarDatos(){
        // ReadLine devuelve la línea leída

        // leer nombre
        string nombre = Console.ReadLine();

        // leer correo
        string correo = Console.ReadLine();

        // agregar a la lista la tupla (nombre,correo);
        Lista.Add((nombre,correo));
    }

}


Karl Mueller: Is There No Room For Dialogue in America?
Over the past 3-4 weeks I've had several experiences that make me wonder about the future of the USA.
Politically, I am a registered independent. I hold some views that are normally considered to the right of the political spectrum (eg. I am pro-life, I think vouchers are a good idea for our public school system), and some views that are generally considered to the left of the political spectrum (I am a firm believer in gun control, I would favour a single payer healthcare system). I also believe that it is possible to have intelligent discussions on political issues without resorting to name-calling, inflammatory language, labeling, etc. I think if we actually listened to each other with humility and "with our hearts" we could actually work together to make positive changes on those issues that our country is grappling with.
However, my experiences of the last few weeks makes it hard for me to believe that our politicians or many of those engaged in politics on the "grass roots" level actually listen to each other -- or want to listen to each other. Instead, each side appears to prefer lecturing each other -- and if the object of the lecture doesn't agree - simple to talk longer, louder and with increasingly more inflammatory language.
A friend of mine and I both had experiences on Facebook recently that illustrate this. He happened to mention that he recently met a well known Republican politician. Immediately he was assailed by what can only be described as "diatribes" by people on the right wing of the Republican party who disagree with this particular politician. The comments were so egregious, that he had to remove them from the post and defriend those involved.
I posted a survey on what people in various countries thought about their respective healthcare systems. This led to a number of individuals attacking me because the US ranked #7 on the survey. Name calling and vilifying resulted. One individual suggested that I leave the USA. When I contacted a particular individual privately, they continued their "lecture". Conversation was impossible. I deleted the entire post and comments & made a public commitment to never say anything remotely political on Facebook again.
Today I received a phone call from a political party asking for my opinion on some issues. When I disagreed with the content of the phone call I was immediately cut off. It was clear that the only people they wanted to talk to were those that agreed with them. Apparently, it is important for me to hear their perspective -- but totally unimportant for them to hear mine.
I know that these are not isolated incidents as a result of contact with a few "crazy" people. As I look over the political landscape of the USA -- I find this kind of behaviour is increasingly becoming the norm.
We don't listen to each other. We demonize those we disagree with. We label people and resort to name calling.
If we continue along this road -- then there is little hope for the positive change in this country.
Hate your next-door neighbor, but don't forget to say grace..."


text:
March 1980 Ebony Magazine - Sammy Davis Junior
Ebony is a monthly magazine that was founded in 1945 by John H. Johnson. Its content focuses on news, culture and entertainment. Ebony was the first magazine geared towards African American readers to reach national circulation. By the beginning of the 21st century, its circulation had reached about 1.8 million people. Initially the content of the magazine was focused only on entertainment and sports figures but it soon opened up to focus on black achievements of all sorts. This entry highlights Sammy Davis Jr. a singer, musician, dancer, comedian, and professional impersonator. Davis began in showbusiness with his father at a young age. His father, who was also an entertainer, was determined to keep custody of him after his divorce and took him on the road. Eventually, Davis became a part of the act with his father and another performer, Will Mastin, to form the Will Mastin Trio which went on tour nationally. Davis's career was interrupted when he was drafted into the army but he returned to show business soon after serving. Davis refusal to appear in any clubs that practiced racial segregation led to the integration of several clubs in Miami Beach and Las Vegas.
Sources: https://www.biography.com/performer/sammy-davis-jr and https://en.wikipedia.org/wiki/Sammy_Davis_Jr.


text:
namespace Microsoft.Azure.Management.Media
{
    using Microsoft.Rest;
    using Microsoft.Rest.Azure;
    using Models;
    using Newtonsoft.Json;

    /// <summary>
    /// </summary>
    public partial interface IAzureMediaServicesClient : System.IDisposable
    {
        /// <summary>
        /// The base URI of the service.
        /// </summary>
        System.Uri BaseUri { get; set; }

        /// <summary>
        /// Gets or sets json serialization settings.
        /// </summary>
        JsonSerializerSettings SerializationSettings { get; }

        /// <summary>
        /// Gets or sets json deserialization settings.
        /// </summary>
        JsonSerializerSettings DeserializationSettings { get; }

        /// <summary>
        /// Credentials needed for the client to connect to Azure.
        /// </summary>
        ServiceClientCredentials Credentials { get; }

        /// <summary>
        /// The unique identifier for a Microsoft Azure subscription.
        /// </summary>
        string SubscriptionId { get; set; }

        /// <summary>
        /// The preferred language for the response.
        /// </summary>
        string AcceptLanguage { get; set; }

        /// <summary>
        /// The retry timeout in seconds for Long Running Operations. Default
        /// value is 30.
        /// </summary>
        int? LongRunningOperationRetryTimeout { get; set; }

        /// <summary>
        /// Whether a unique x-ms-client-request-id should be generated. When
        /// set to true a unique x-ms-client-request-id value is generated and
        /// included in each request. Default is true.
        /// </summary>
        bool? GenerateClientRequestId { get; set; }

        /// <summary>
        /// Gets the IAccountFiltersOperations.
        /// </summary>
        IAccountFiltersOperations AccountFilters { get; }

        /// <summary>
        /// Gets the IOperations.
        /// </summary>
        IOperations Operations { get; }

        /// <summary>
        /// Gets the IMediaservicesOperations.
        /// </summary>
        IMediaservicesOperations Mediaservices { get; }

        /// <summary>
        /// Gets the IPrivateLinkResourcesOperations.
        /// </summary>
        IPrivateLinkResourcesOperations PrivateLinkResources { get; }

        /// <summary>
        /// Gets the IPrivateEndpointConnectionsOperations.
        /// </summary>
        IPrivateEndpointConnectionsOperations PrivateEndpointConnections { get; }

        /// <summary>
        /// Gets the ILocationsOperations.
        /// </summary>
        ILocationsOperations Locations { get; }

        /// <summary>
        /// Gets the IAssetsOperations.
        /// </summary>
        IAssetsOperations Assets { get; }

        /// <summary>
        /// Gets the IAssetFiltersOperations.
        /// </summary>
        IAssetFiltersOperations AssetFilters { get; }

        /// <summary>
        /// Gets the ITracksOperations.
        /// </summary>
        ITracksOperations Tracks { get; }

        /// <summary>
        /// Gets the IOperationStatusesOperations.
        /// </summary>
        IOperationStatusesOperations OperationStatuses { get; }

        /// <summary>
        /// Gets the IOperationResultsOperations.
        /// </summary>
        IOperationResultsOperations OperationResults { get; }

        /// <summary>
        /// Gets the IContentKeyPoliciesOperations.
        /// </summary>
        IContentKeyPoliciesOperations ContentKeyPolicies { get; }

        /// <summary>
        /// Gets the ITransformsOperations.
        /// </summary>
        ITransformsOperations Transforms { get; }

        /// <summary>
        /// Gets the IJobsOperations.
        /// </summary>
        IJobsOperations Jobs { get; }

        /// <summary>
        /// Gets the IStreamingPoliciesOperations.
        /// </summary>
        IStreamingPoliciesOperations StreamingPolicies { get; }

        /// <summary>
        /// Gets the IStreamingLocatorsOperations.
        /// </summary>
        IStreamingLocatorsOperations StreamingLocators { get; }

        /// <summary>
        /// Gets the ILiveEventsOperations.
        /// </summary>
        ILiveEventsOperations LiveEvents { get; }

        /// <summary>
        /// Gets the ILiveOutputsOperations.
        /// </summary>
        ILiveOutputsOperations LiveOutputs { get; }

        /// <summary>
        /// Gets the IStreamingEndpointsOperations.
        /// </summary>
        IStreamingEndpointsOperations StreamingEndpoints { get; }

    }
}


text:
welcome to GISTofTHIS
Entertainment, Lifestyle, Fashion, Politics, Health tips, Gist and many more...
Endsars – Death Toll Now 73 With 205 Police Stations Burnt
-71 public warehouses, 248 private stores looted -IG to policemen: With 22 personnel killed, defend yourselves when attacked -Obong of Calabar: Ayade's insensitivity fuelled Cross River's violence By Kingsley Nwezeh in Abuja, Segun James in Lagos and Bassey Inyang in Calabar
US scientists launch world's biggest solar geoengineering study
Research programme will send aerosol injections into the earth's upper atmosphere to study the risks and benefits of a future solar tech-fix for climate change
Scientists say the planet could be covered with a solar shield for as little as $10bn a year. Photograph: ISS/Nasa
US scientists are set to send aerosol injections 20km up into the earth's stratosphere in the world's biggest solar geoengineering programme to date, to study the potential of a future tech-fix for global warming.
The $20m (£16m) Harvard University project will launch within weeks and aims to establish whether the technology can safely simulate the atmospheric cooling effects of a volcanic eruption, if a last ditch bid to halt climate change is one day needed.
Scientists hope to complete two small-scale dispersals of first water and then calcium
carbonate particles by 2022. Future tests could involve seeding the sky with aluminium oxide – or even diamonds.
"This is not the first or the only university study," said Gernot Wagner, the project's co-founder, "but it is most certainly the largest, and the most comprehensive."
Janos Pasztor, Ban Ki-moon's assistant climate chief at the UN who now leads a geoengineering governance initiative, said that the Harvard scientists would only disperse minimal amounts of compounds in their tests, under strict university controls.
"The real issue here is something much more challenging," he said "What does moving experimentation from the lab into the atmosphere mean for the overall path towards eventual deployment?"
Geoengineering advocates stress that any attempt at a solar tech fix is years away and should be viewed as a compliment to – not a substitute for – aggressive emissions reductions action.
But the Harvard team, in a promotional video for the project, suggest a redirection of one percent of current climate mitigation funds to geoengineering research, and argue that the planet could be covered with a solar shield for as little as $10bn a year.
Some senior UN climate scientists view such developments with alarm, fearing a cash drain from proven mitigation technologies such as wind and solar energy, to ones carrying the potential for unintended disasters.
Kevin Trenberth, a lead author for the UN's intergovernmental panel on climate change, said that despair at sluggish climate action, and the rise of Donald Trump were feeding the current tech trend.
"But solar geoengineering is not the answer," he said. "Cutting incoming solar radiation affects the weather and hydrological cycle. It promotes drought. It destabilizes things and could cause wars. The side effects are many and our models are just not good enough to predict the outcomes"
Natural alterations to the earth's radiation balance can be short-lasting, but terrifying. A 1991 Mount Pinatubo eruption lowered global temperatures by 0.5C, while the Mount Tambora eruption in 1815 triggered Europe's 'year without a summer', bringing crop failure, famine and disease.
A Met Office study in 2013 said that the dispersal of fine particles in the stratosphere could precipitate a calamitous drought across North Africa.
Frank Keutsch, the Harvard atmospheric sciences professor leading the experiment, said that the deployment of a solar geoengineering system was "a terrifying prospect" that he hoped would never have to be considered. "At the same time, we should never choose ignorance over knowledge in a situation like this," he said.
"If you put heat into the stratosphere, it may change how much water gets transported from the troposphere to the stratosphere, and the question is how much are you [creating] a domino effect with all kinds of consequences? What we can do to quantify this is to start with lab studies and try to understand the relevant properties of these aerosols."
Stratospheric controlled perturbation experiments (SCoPEX) are seen as "critical" to this process and the first is planned to spray water molecules into the stratosphere to create a 1km long and 100m wide icy plume, which can be studied by a manoeuvrable flight balloon.
If lab tests are positive, the experiment would then be replicated with a limestone compound which the researchers believe will neither absorb solar or terrestrial radiation, nor deplete the ozone layer.
Bill Gates and other foundations are substantially funding the project, and aerospace companies are thought to be taking a business interest in the technology's potential.
The programmme's launch will follow a major conference involving more than 100 scientists, which begins in Washington DC today.
Solar geoengineering's journey from the fringes of climate science to its mainstream will be sealed at a prestigious Gordon research conference in July, featuring senior figures from the National Oceanic and Atmospheric Administration (NOAA) and Oxford University.
Pasztor says that most scientific observers now see the window to a 1.5C warmed world as "practically gone" and notes that atmospheric carbon dioxide concentrations will continue rising for many decades after the planet has reached a 'net zero emissions' point planned for mid-late century.
But critics of solar radiation management approach this as a call to redouble mitigation efforts and guard against the elevation of a questionable Plan B.
"It is appropriate that we spend money on solar geoengineering research," said Kevin Anderson, the deputy director of the Tyndall Centre for Climate Change Research. "But we also have to aim for 2C with climate mitigation and act as though geoengineering doesn't work, because it probably won't."
Kaduna State governor, Nasir El-Rufai has tested positive for coronavirus
Kaduna State governor, Nasir El-Rufai has tested positive for coronavirus. "Earlier this week, I submitted a sample for the Covid-19 test," El-Rufai said in a
Just in: US threatens to block China Telecom from American market
The United States of America threatened on Thursday, April 9, to cut off Beijing-controlled China Telecom from serving the US market because of legal and security risks, the Justice Department announced. A recommendation by the government's top departments, including Defense, State and
Fake police overpowered 66,241 officers in Kogi, Bayelsa'
Helicopter was on mission to scare troublemakers, says IGP • PDP kicks, says explanation 'speaks volumes' • Dickson rejects results, says election was military coup The Inspector General of Police, Mohammed Adamu, yesterday blamed the
Theme images by caracterdesign
see also: davido did not perform in congo
Gistofthis
Get news at your doorstep
Once a week we send a digest with the most popular articles.


text:
Music Business Podcast - Music Business Worldwide
'I hate the word "rules". It's the antithesis of A&R.'
The MBW Podcast offers a probing monthly audio interview with some of the true thought leaders of the global music business. The Podcast is supported by SoundExchange, which has paid out more than $4bn to artists and rights-holders to date.
It's not easy breaking artists right now – especially when you're committed to building careers.
Just two debut artist albums went Gold in the US in the first six months of this year: Nine Track Mind by Charlie Puth and Islah by Kevin Gates.
Both of them happen to be on the same label: Mike Caren's Artist Partners Group – an 'independent major' imprint of Atlantic Records run out of Hollywood, Los Angeles.
Islah has since gone Platinum, in a year when others are struggling to gain traction for emerging artists in the US and beyond.
So what's Caren's secret?
Atlantic Chairman & CEO Craig Kallman and Chairman & COO Julie Greenwald say: "Mike Caren's A&R instincts are exceptional, and he has signed an amazing roster of artists across a range of genres."
Caren (pictured) partly puts APG's success down to its determination to keep its roster manageable, and therefore dedicate more creative resources to each artist than other labels can muster..
"We [at APG] believe that, if you are a star, you still have to essentially work harder than all your competition," he says in the reborn MBW Podcast, available to listen to above. "We don't sign [acts] who don't have that."
"The A&R timeline of signing and [breaking] an artist in 12-18 months is unrealistic."
He adds: "Very few people have really studied the business [enough] to understand that the A&R timeline people have in their head of signing and being successful in 12-18 months is unrealistic.
"Possibly the reason why a lot of artists are successful on their second record deals is that the first team wasn't patient enough.
"The real lifetime [to break an artist after signing them] is two years-plus. Advances are going to burn out before then – you need a business model that can make it to that point."
Mike Caren started his career in A&R 21 years ago, aged 17, at Atlantic subsidiary Big Beat Records. Since then, he has signed or co-signed over 20 artists that have achieved gold or platinum status.
From 2009 to 2012, he served as Co-President alongside John Janick of the relaunched Elektra Records (Bruno Mars, Ed Sheeran, Cee Lo Green).
He established Artist Partners Group in 2013 as a sister company to Artist Publishing Group, which is administered by Warner/Chappell.
In addition to APG, he has a global remit as Warner Music Group's Creative Officer.
"artists are not binary objects – they are human beings who are constantly changing."
Outside of A&R, Caren is also an active songwriter having written and/or produced for Beyoncé, Kanye West, Bruno Mars, Cobra Starship, Flo Rida, Trick Daddy, Asher Roth, and others.
"Being a producer and writer, I've realised that there's no single rule to making a great record," he says on the podcast.
"The records I've been a part of, some of them started from scratch with me in a bedroom… and with others I've come in on [late] with ideas of how to make a significant difference."
He adds: "There really are no rules. I hate the word 'rules'. It's the antithesis of A&R."
Caren encourages the industry to remember that artists, especially young artists, grow up quickly – and that you might not be dealing with the same individual at 19-years-old than you were two years previous.
"We have a tendency as organised human beings to make a list and scratch them off: 'I've seen that person, they are X, Y or Z'," he says.
"We're not talking about binary objects, we're talking about people who are constantly changing."
Other topics discussed on the MBW Podcast include Caren's working relationship with Warner/Atlantic executives such as Craig Kallman and the legendary Ahmet Ertegun, as well as Jac Holzman – the founder of Elektra and the man who discovered The Doors.
We also ask Caren about dropping artists – and learning from experiences with talent when things don't work out as planned.
"The part of the business that gives me the most pleasure is breaking new artists and new writers," he says.
"More than half of the successful artists I've signed have been dropped by other labels.
"Some of the most problematic parts of the music industry are those who believe that other people's failures are their success."
"If you are the first signing an artist and it isn't working… it's just not Yin and Yang… there's another chance for success for them; a new, fresh approach to be tackled and the potential for success knowing how many artists didn't figure it out first time round."
He adds: "Lyor [Cohen] passed on [the advice] that if you find yourself in a position where you have to drop an artist, you want to root for them and make it as smooth as possible… and legitimately hope they're successful.
"Some of the most problematic parts of the music industry are those who believe that other people's failures are their success. That's just the wrong mentality. We owe it to every artist who trusts us to do our best to make them successful.
"I don't look at us competing against [other labels] as much as I look at us competing against video games, apps and movies – people's time and attention."
SoundExchange operates at the center of digital music, developing solutions to benefit the entire music industry.
The organization collects and distributes digital performance royalties and administers direct license agreements on behalf of more than 130,000 recording artists and master rights owners accounts.
Learn more about SoundExchange at www.SoundExchange.com orwww.facebook.com/soundexchange.
Interviews United States MBW Podcast Mike Caren Podcast SoundExchange
Mike Caren's APG goes fully independent, as label's artist roster moves inside Atlantic Records
Esther-Mireya Tejeda appointed Chief Marketing and Communications Officer at SoundExchange
SoundExchange – Manager, International Rights Management (US)
'All music creators should receive fair compensation for their work, regardless of where they are from.'
Music Business Podcast
Music Business Worldwide prides itself on our in-depth and revelatory interviews with business leaders – and our podcast is no different.
If you want to find out what the brightest and best brains in the music industry are thinking, these downloadable audio discussions are a perfect complement to your commute.
If you represent a thought leader in the industry who you believe would make a perfect MBW podcast guest, please email enquiries@musicbizworldwide.com
MBW Podcast


The objective of this course is to introduce the basic concepts of population pharmacokinetics (PK)/ pharmacodynamics (PD) and NONMEM analysis.
Deadline for registration is September 4, 2019. Contact ICON's Lisa Wilhelm-Lear to learn more and reserve your spot.
The objective of this course is to introduce the basic concepts of population pharmacokinetics (PK)/ pharmacodynamics (PD) and NONMEM analysis. The course is targeted to individuals interested in learning to solve population pharmacokinetic problems, and we have prepared the course in a general manner as to include a wide background of participants. The course will demonstrate how NONMEM, using the graphical user interface software PDx-Pop, can be used to solve practical population PK/PD problems, using a hands-on format with specific examples. This allows participants to work through the problems with the instructor, to develop a thorough understanding of the software and to establish confidence in applying the software to population pharmacokinetic problems.
Attendees will be instructed on the basic theory of mixed effects analysis, receive hands-on instruction of creating PK and PD models in NONMEM, learn to manage projects using PDx-POP, a graphical user interface software specifically designed for NONMEM, develop covariate models, and implement various graphical and statistical methods for validating models using PDx-POP's supplementary statistical and graphical tools. After attending this course, the participate will understand the fundamentals of population analysis; be able to run NONMEM with PDx-Pop; know how to apply some of the methods used to perform population analysis; know how to explore, develop, and evaluate population models; know how to estimate the mean pharmacokinetic (PK) and/or pharmacodynamic (PD) parameters in a population of patients; and be able to investigate and identify fixed effect sources of variability (covariates) which influence the PK and PD of a drug.
This two-day course and the workshop's third day course, the Advanced course, are part of one series. Interested parties may register for the first two days (this course), the third day (Advanced course), or a combination of all three courses.
Robert Bauer (Robert.Bauer@iconplc.com) holds a PhD. in Pharmacology. He heads the Pharmacometrics R&D department at ICON Plc, Gaithersburg, MD, where he and his group maintain the population analysis software NONMEM®, incorporating leading edge algorithms in pharmacometrics. Dr. Bauer's focus is on developing and implementing mathematical and statistical algorithms for biomedical problems.
Brian Sadler, Ph.D., Senior Scientific Director, Pharmacokinetics, Pharmacodynamics, Modeling and Simulation, joined ICON in 2010 and brings 37 years of relevant experience from the perspectives of his previous positions as a PKDM scientist at RTI International, a project pharmacokineticist at GlaxoSmithKline, an instructor and domain expert at a Pharsight, and as the principal and owner of his own pharmacometric consulting company. Dr. Sadler earned his Ph.D. in Pharmacology and B.A. in Biology from the University of Missouri - Columbia.
Indrajit Das, PhD. Indrajit Das holds a PhD. in Physics. He is Scientist I in Pharmacometrics R&D department at ICON Plc, Gaithersburg, MD., where he develops and maintains the population analysis software NONMEM®'s Graphical User Interface and post-processing tool PDx-Pop, incorporating leading edge algorithms using Java, Perl and R. Dr. Das's focus is on developing and implementing Object Oriented Programming principles and practices such that PDx-Pop seamlessly works with NONMEM.
A discount of 15% is available to groups of 3 or more participants from the same organization.


Applicants are required to have a Bachelor's degree or higher from an accredited college or university, with a minimum 2.5 GPA on the last 60 semester or 90 quarter units.
Applicants are required to have at least five years of middle and/or upper-level professional management work experience.
Extent and nature of professional experience.
Leadership potential and other personal qualities that demonstrate academic and professional promise.
Applicants are expected to have taken the GMAT or GRE prior to addmission to the program.
After review of completed application portfolios, the MBA Programs Director will identify viable program candidates, who are contacted to schedule an interview. Final admission decisions are made following this interview.


aarons living room furniture. You probably know already that aarons living room furniture has become the most popular topics on the internet nowadays. Based on the files we got from adwords, aarons living room furniture has very much search in google search engine. We feel that aarons living room furniture supply fresh concepts or references for audience.
We've learned numerous sources concerning aarons living room furniture but we think this one is the best. I we do hope you would also agree with our thoughts. This image has been posted by admin and is in category tags section. You could download this image by hitting the save link or right click the image and choose save.
We hope what we give to you could be useful. If you wish, youre able to distribute this post for your friend, loved ones, community, or you can also book mark this page.


text:
Q: Restrict Restful Api Access to Flutter client only? I need to create a Restful API backend for my flutter app using NodeJS with Mysql. I'd like to restrict endpoint access to just the Flutter client. The user shouldn't have to register and the only requirement is that the API is accessed through the Flutter app. I thought I might be able to make use of an FCM token which is generated as soon as the app is fired up. But I'm guessing this would require some kind of anonymous registration of the token to the database.
I wonder if there's a simpler way that I'm overlooking?