text:
Arts, Culture & Lifestyle
Properties, Tech & Motoring
Bernard Arnault Now Owns Leonardo Da Vinci's Residence and Vineyard
Bernard Arnault, the famed entrepreneur and owner of the ultra-luxury group LVMH, has added a new property under his name. The billionaire is the new owner of Casa degli Atellani, the former residence of Leonardo Da Vinci, a polymath and master painter. Located in the city centre of Milan, the property's previous occupants include the […]
Dec 30, 2022 | By LUXUO
Bernard Arnault, the famed entrepreneur and owner of the ultra-luxury group LVMH, has added a new property under his name. The billionaire is the new owner of Casa degli Atellani, the former residence of Leonardo Da Vinci, a polymath and master painter. Located in the city centre of Milan, the property's previous occupants include the descendants of the Conti and Portaluppi families.
At press time, the transaction and purpose of this acquisition were not disclosed.
The majestic estate was built in the late 1400s and donated to Da Vinci by Ludovico "Il Moro" Duke of Milan in 1498 when the painter was in town to paint his magnum opus — The Last Supper. Through the years, Casa degli Atellani saw multiple changes of hands and ownership and in 1919, it was acquired by the senator and entrepreneur Ettore Conti.
READ MORE: Top 10 Philanthropists in the World
Located on Corso Magenta, the estate underwent restoration works under the direction of Piero Portaluppi, who is a famous architect and son-in-law of Conti. Within the grand country house's verdant courtyard is a hidden vineyard that once belonged to Da Vinci. It was the only wine-producing landholding in the centre of Milan and spans around two acres or 16 rows. Restored in 2014, after years of neglect, it was restored to its former glory in 2015 during the international Expo held in the capital city. The public could once again indulge in the wines made in Milan.
A post shared by La Vigna di Leonardo (@lavignadileonardo)
The revitalisation of Casa degli Atellani saw it become a top destination for fashion shows, presentations and cocktail receptions. Tourists and visitors often earmark the estate as one of the places to visit. There are also six for-rent apartments that could be utilised.
The multi-billionaire's portfolio includes some of the world's most luxurious brands like Louis Vuitton, Dior, Tiffany & Co., Bvlgari and others. He also owns several wines and spirits firms, namely Ruinart, Dom Perignon, Moet & Chandon and Veuve Clicquot. Being one of the richest in the world, Arnault is always at the top of the list and often competes with Tesla and Twitter owner Elon Musk for the crown. As of December 2022, Forbes estimates Arnault to have a net worth of US$181.8 billion.
For more property reads, click here.
Branding Association of Malaysia turns 22
Gift Guide: Ignite your dreams with the new Swarovski Holiday 2022 collection
The glorious Montreux and Zurich
Web3 Is Entering Maintstream Market
Load Next Article.
Feeling The Fendissime — Fendi at Villa Medici
Harry and Meghan's Montecito Mansion on Sale for US$33.5 Million
The 17th PropertyGuru Asia Property Awards Grand Finale 2022
Designing For The Future — Circularity Mission
Follow us on Instagram @luxuo.my
Copyright © 2023 LUXUO. All Rights Reserved.
Contact | Terms and Conditions | Privacy Policy

redpajama_set_name: RedPajamaCommonCrawl


Heavenly Feet shoes are anti-fatigue footwear, designed to offer the very best in comfort with great style too. You can be confident of stress-free, ache-free feet with Heavenly Feet shoes.
Heavenly Feet are very focused on quality and comfort, so you can be assured of the very best care for your feet when you order a pair of Heavenly Feet shoes or boots. There is a careful mix of contemporary and traditional styling, ultimately to make sure there is something to your tastes.
We've all experienced the frustration of looking for shoes which are comfortable to wear but don't look ghastly. Heavenly Feet are the solution - their range of shoes is perfect, including dainty looking styles for summer wear with dresses, as well as smarter designs for work outfits.
Some of us do suffer a lot more than others with our feet - so much so, we have barely any confidence in buying shoes on the internet. But you can be sure of Heavenly Feet's attention to real comfort for real women. They use genuine leather linings and heel cushioning to provide you with excellent comfort throughout your time wearing the shoes. So you won't be limited to a 10 minute walk before your feet ache - Heavenly Feet have created this range to make longer walks an absolute dream. Plus, all styles use full cushioned 'in-socks' to add to the comfort, with lightweight and flexible outsoles.
Along with butter soft leather uppers on these Heavenly Feet shoes, you know you're getting the very best quality for your feet.


I was searching for a Property and found the listing (4417 Swilcan Bridge Lane N, Jacksonville, FL 32224 (MLS® #361840)). Please send me more information regarding 4417 Swilcan Bridge Lane N, Jacksonville, Florida, 32224. Thank you!
I'd like to request a showing of 4417 Swilcan Bridge Lane N, Jacksonville, Florida, 32224. Thank you!


text:
Home Tags Posts tagged with "Maine"
Ebola nurse Kaci Hickox defies quarantine order by leaving her house in Maine
Nurse Kaci Hickox has defied the Ebola quarantine order, leaving her house in Maine for a brief bike ride.
She returned from treating Ebola patients in Sierra Leone on October 24.
Kaci Hickox maintains isolation is unnecessary, as she has no symptoms and has tested negative for Ebola.
Maine officials have vowed to go to court to try to enforce the quarantine.
About 5,000 people have died of the disease in West Africa, but only nine patients have been treated for the virus on US soil.
More than 13,700 people have been sickened in the Ebola outbreak, the vast majority in Liberia, Sierra Leone and Guinea.
Ebola, which is only spread through close contact with the bodily fluids of a sick patient, has a 21-day incubation period.
Kaci Hickox returned to the US from Liberia on October 24, landing at Newark International Airport
US officials are at odds over whether American healthcare workers who return from treating Ebola patients in West Africa should be forced into quarantine until that period has expired.
New Jersey and other states had put quarantine rules into place after a New York doctor who treated Ebola patients in West Africa came down with the disease.
The US Centers for Disease Control and Prevention (CDC) merely recommends daily monitoring of returned health workers, rather than enforced isolation.
President Barack Obama has warned that overly restrictive measures imposed upon returning healthcare workers could discourage them from volunteering in Africa.
"We know that the best way to protect Americans ultimately is going to stop this outbreak at the source," he said on October 29 .
Kaci Hickox returned to the US on October 24, landing at Newark International Airport.
Officials say she had a minor fever, necessitating a quarantine at a Newark, New Jersey, hospital.
Kaci Hickox contested the quarantine regimen, ultimately threatening legal action.
After showing no fever or other symptoms for a 24-hour period, Kaci Hickox was discharged and brought to her home state of Maine.
"I'm not willing to stand here and let my civil rights be violated when it's not science-based," she told reporters on Wednesday evening.
On Thursday morning, Kaci Hickox left her home on a bicycle, followed by police officers who monitoring her movements and public interactions. She returned home shortly after.
Without a court order, the police were barred from detaining her.
[youtube iL_ONS-O9A4 650]
[youtube pSNMnW4kRQI 650]
Michigan and Maine power outages on Christmas Day
More than 200,000 homes and businesses remained without electric power for a fourth day in parts of Michigan and Maine.
Utility crews worked through the Christmas Day to try to restore electricity cut off by a severe ice storm Sunday.
The worst affected state was Michigan, with about 158,000 customers remained without power at 2 p.m. ET on Christmas Day, utilities companies said.
More than 59,000 customers in Maine continue to lack power. Crews were putting the final patches on power lines in Vermont and New York state, where outages were in the thousands earlier this week.
More than 200,000 homes and businesses remained without electric power for a fourth day in parts of Michigan and Maine
With temperatures far below freezing, ice on power lines was refusing to budge after the severe weekend weather.
Most of the hotels and motels around Flint, Michigan, had no vacancies Tuesday night as families poured in from hard-hit towns to be somewhere warm for the holiday.
In Maine, emergency officials across the state said the ice storm had created the worst conditions since the Great Ice Storm of January 1998, which left some parts of New England without power for months.
In Waldo County, more than 30,000 customers were without power Tuesday night — equivalent to about three-quarters of the county's entire population.
[youtube kSPqwEEcJs0 650]
Elor Azaria: Israeli Soldier Convicted of Manslaughter over Hebron Killing
Israeli soldier Elor Azaria, who was filmed shooting dead a wounded Palestinian attacker after he had been disarmed of a …Read More »
Michael Clarke Duncan hospitalized after suffering heart attack
Actor Michael Clarke Duncan has been hospitalized in Los Angeles after suffering a heart attack. His publicist Joy Fehily says …Read More »
German Man Killed by Runaway Elephant
A German walker was attacked and killed by an elephant which had escaped from a circus, police say. The 65-year-old …Read More »
ZunZuneo: US created Cuban Twitter to foment unrest
According to an investigation by the Associated Press news agency, the US secretly created ZunZuneo, a text-message social network designed …Read More »
Plane passengers could have to follow a dress code on board
Plane passengers could be obliged to follow a dress code after carriers received many calls from flyers' rights groups to …Read More »


text:
Canada Legalizes Recreational Marijuana
Canada has legalized the use of recreational weed in the whole country making it the second country in the world to do so.
Marijuana has been legalized in Canada and fulfills a campaign pledge by Prime Minister Trudeau
The legalization took effect on October 17
Adults aged 18 and above can now grow, use and share licensed marijuana
It is illegal to carry marijuana into or out of Canada's borders.
Canada has made legal the use of recreational marijuana becoming the second country to do so in the world. The move has been welcomed with cheers and long queues as people line up to purchase marijuana which began selling on October 17.
The legalization of Marijuana is a fulfillment of a campaign promise made by Prime Minister Justin Trudeau which he thought was the solution to reduce crimes related to marijuana abuse as well as protecting kids from using it. Acting on this pledge, the Upper House of Parliament in Canada approved a revised bill paving way for the sales of marijuana in retail stores in the whole country. The Cannabis Act aims to control production, distribution, the sale and use of marijuana in Canada.
The old approach to #cannabis didn't work. It was too easy for our kids to get it and gangs & drug dealers were reaping the profits. That changes from now on. #promisekept pic.twitter.com/P2k9tB9zyZ
— Justin Trudeau (@JustinTrudeau) 18 октября 2018 г.
Henceforth, it will now be possible for adults to buy and use recreational weed. By extension, an adult can also grow marijuana either for personal use. Some health professionals are, however, pessimistic about the legalization of marijuana but the Act has tried to dispel these concerns through a rigorous raft of regulatory measures.
How Old Do You Have to Be to Consume Recreational Weed?
Only adults above 18 years of age will be allowed to use marijuana. However, the age limit is not the same across the country and varies from one state to the other. For example, it is 18 on Alberta and Quebec but 19 in the rest of the territories. A person is only allowed to be in possession of 30 grams of legal marijuana and can share legal marijuana of a similar quantity with other users of legal age. If one household intends to grow marijuana for personal, they ought to plant a maximum of 4 licensed seeds or seedlings.
As of now, there are not many retail stores selling the product but many regulated stores are definitely going to come up.
All the newbies in 2⃣days 🤗Enjoy 💕#LegalizeIt #legalization #Oct17 #iamcannabis #weedmemes #canadacannabis pic.twitter.com/ZrBda6zpBM
— The Best Buds 👯 (@thebestbudss) 15 октября 2018 г.
For those who wish to travel with marijuana across Canadian borders, they will find themselves on the wrong side of the law. It is illegal to be in possession of marijuana regardless of whether you are coming into or going out of Canada.
It is also good news for those currently serving convictions as a result of being in possession of not more than 30 grams of marijuana. Soon, the authorities will start implementing plans to pardon them.
Canada now joins Uruguay which legalized recreational use of marijuana in December 2013. 9 states in the US have also legalized recreational marijuana with medical marijuana being legalized in 30 states.
The post Canada Legalizes Recreational Marijuana appeared first on VapingDaily Blog.


All gardeners know that sinking feeling: you\'ve gone to so much trouble to raise those tender plants, but when you come out one morning you discover the awful decimation!
We can\'t be sure why slugs, snails, and other pests don\'t care to feast on dandelions or nettles, but we do know that when we plant out anything of value, sure enough, the wee beasties will gnaw through stems and scoff all the leaves in no time! This is where raised beds come into their own.
Once you\'ve isolated your growing area with raised beds, the territory is much easier to defend against those menacing midnight raiders!
The Victorians often built their raised beds in brickwork, but you need a certain degree of expertise to build halfway decent brick walls. It\'s far easier to use wood in your projects, with the added bonus that – if you ever want to shift the raised beds to another location – you can generally reuse the wood.
Once you\'ve built raised beds for your shrubs, it will immediately help prevent many creepy crawlies getting at your \'little darlings\', but there\'s still more you can do. One trick is to beef up your defences by treating the sides of the raised bed with barriers which no snail or slug would ever dare broach! The gardeners of yesteryear used all manner of preparations, such as sticky oils and tars as an insect barrier, but these are quite messy, so it\'s probably best try some of the proprietary methods now on sale, such as special sticky tapes or copper strips which are very easy to buy and apply.


text:
Q: Change date string from Dutch to English to use it in strtotime I have the following Dutch string date:
dinsdag, 18 april 2017

Now I want to strip the day and the month, and I can do that with the following example, but that doesn't work because its in Dutch and strtotime only works with English strings.
$stripDay = date('d',strtotime($date));
$stripMonth = date('m',strtotime($date));

So I checked for other options, and I found strptime function which states that it can work.
$format = '%l, %d %m %Y';
setlocale(LC_TIME, 'NL_nl');
setlocale(LC_ALL, 'nl_NL');

First I configured the format, and then I set the Locale. But if I use the following code it still gives me 1's back.
$stripDay = date('d',strptime($date));
$stripMonth = date('m',strptime($date));

Can someone explain to me what I am doing wrong here?

A: you can define array which contain english days and dutch day and then you can replace dutch string with english string like this:
<?php
    function dutch_strtotime($datetime) {
        $days = array(
            "maandag"   => "Monday",
            "dinsdag"   => "Tuesday",
            "woensdag"  => "Wednesday",
            "donderdag" => "Thursday",
            "vrijdag"   => "Friday",
            "zaterdag"  => "Saturday",
            "zondag"    => "Sunday"
        );

        $months = array(
            "januari"   => "January",
            "februari"  => "February",
            "maart"     => "March",
            "april"     => "April",
            "mei"       => "May",
            "juni"      => "June",
            "juli"      => "July",
            "augustus"  => "August",
            "september" => "September",
            "oktober"   => "October",
            "november"  => "November",
            "december"  => "December"
        );

        $array = explode(" ", $datetime);
        $array[0] = $days[strtolower($array[0])];
        $array[2] = $months[strtolower($array[2])];
        return strtotime(implode(" ", $array));
    }
    $date = "woensdag 22 oktober 2014 08:41:42";
    echo date("l d-m-Y H:i:s", dutch_strtotime($date)) . "<br />";
    echo date("d-m-Y", dutch_strtotime($date));
?>

A: If you're running PHP with Intl you can use the IntlDateFormatter class rather than rolling your own translations:
$df = IntlDateFormatter::create(
    'nl_NL',
    IntlDateFormatter::FULL,
    IntlDateFormatter::FULL,
    'Europe/Amsterdam',
    IntlDateFormatter::GREGORIAN,
    'eeee, d MMMM yyyy'
    );

// since the time is omitted from the string
// it uses 00:00 - which meant the timestamp
// was an hour off for me in the UK so it
// was rolling the date back to 23:00 the
// previous day. Forcing UTC sorts this.
$df->setTimeZone('Etc/UTC');

// outputs '2017-04-18'
echo date('Y-m-d', $df->parse('dinsdag, 18 april 2017'));

You'll probably need the ICU date format guide handy though as it's different to normal PHP date formatting (hence 'eeee' for the day).

redpajama_set_name: RedPajamaStackExchange


text:
There Has Never Been A Film Like The Act of Killing
This is not a review, it is analysis and as such involves spoilers.
When I first heard the premise for The Act of Killing it sounded like a terrible idea. I'm still not convinced that it wasn't. Part of my appreciation of this film is my continued astonishment that it was made at all. There has never been a movie like The Act of Killing. The movie itself and the situations it creates are unique in a profoundly unsettling way.
From both what is stated in the film and from reading interviews with the film's director, Josh Oppenheimer, it seems that his goals were to have the killers confront their crimes and realize what they had done. Oppenheimer also wanted to contribute to a larger awakening in Indonesia about the cost of allowing these people to not only go unpunished but to be publicly lauded.
It is the first goal that is most questionable. Why engage with these men at all? Why give them further attention and yet another platform for exposure? Why indulge their narcissism? At the end of the film we watch Anwar retch and dry heave as he stumbles around the scene of his crimes but I find no sense of satisfaction or closure. Are we meant to be impressed by his awakening? Are we to praise him for his penitence? It is estimated that Anwar personally killed more than 1000 people with his own hands, mostly through strangulation. Can this level of criminality ever be atoned for or forgiven?
The goal of the film is questionable but the means of achieving the goal are worse. The reenactments that these killers stage clearly traumatize the actors and participants. Not only this but the killers clearly revel in the trauma they induce like vampires relishing blood.
Current psychological models of how the emotional brain or limbic system works point to trauma being timeless. Trauma occurs in a very old and primitive part of the brain. It has no sense of time. If you are bitten by a dog when you were six years old, you may well find that thirty years later a dog can trigger the same fear response as if you were right back at the first occurrence. It used to be thought that re-triggering the trauma in a therapeutic setting could possibly disarm it, but some now believe it only re-traumatizes the subject.
These Indonesian "actors" participating in this reenactment are clearly being triggered and losing sight of what is real and what is memory. In addition the perpetrators of the trauma are also confused. Their rationalizations, and narcissistic delusions make it impossible for them to find their way to reality. What we end up with is a memory, distorted by psychological pathology that is then enacted by people who aren't sure if they are acting or reliving the past. All the while both groups are creating a film that will serve as yet another even newer memory in lieu of a film. This whole process in turn is being filmed by Oppenheimer who creates yet another layer between us and the now thoroughly twisted reality of the past.
Once reality is lost all that we have left is an ever shifting dream world. At the end of the film we watch the closing scene of the killers reenactment film. Anwar and Herman stand in front of a waterfall. Anwar is dressed like Saint Francis with his hands open to the masses, while Herman is dressed in a bright, blue ballgown and hat. Their victims line up, bloody and disheveled, to thank their murderers for murdering them. Never in the history of film has a situation like this been filmed. We are exploring new territory. When Werner Herzog was shown just a few scenes from The Act of Killing he said, "I looked at it and I immediately knew I had never seen anything like that. I'd never seen anything as powerful as frightening and as surreal as what was on the screen." Errole Morris said "To call it surreal I don't think really does it justice. At its heart it's outrageous which is one of the things that makes it really, really, interesting."
It's that last sentence that bothers me. What are we to do with this film? What are witnessing? The camera man just keeps filming while Safit Pardede, surrounded by a still burning set, reminisces with great nostalgia about how he used to rape children. At that point do you not drop the camera and run? What exactly should you do?
Alex Woodson, writing for the Carnegie Council for Ethics in International Affairs wrote, "There has probably never been a film that bears even the slightest resemblance to The Act of Killing and it is highly improbable we will ever see anything like it again." I must agree, and perhaps that is good thing.
There is that sensation we have when someone confronts us and we only think of what to say long after the confrontation is over. Watching The Act of Killing is so shocking so disorienting the viewer doesn't have time to compose a response. In truth I've watched it three times in as many years and I still don't have a response. What I know is that this film has gone to a place unvisited by cinema as of yet. It reveals something horrible but undeniable about humanity and perhaps for that reason it justifies its existence.
If you enjoyed this article you may also enjoy this -
Who's Side Of The Camera Are You On?
Nazi officers wore hats emblazoned with a big skull right in the center, and yet it never occurred to them that they…
Omo Child: A Challenge for Multiculturalism
Currently, western culture embraces the tenets of multiculturalism. There is a desire to recognize all cultures and…
The Avengers: Endgame is a (super) heroic goodbye to white saviors
Tim Gruver
'Free Solo' and the Zen of Rock Climbing
Eric Coyote
Sony, There's Other Spider-Ladies You Can Start With
M.H. Williams in Into The Discourse
The Curious Case of First Man
Jeffrey Zhang in Strange Harbors
"1917" is the Herald of a New Age of Cinema
Oren Cohen in The Geek Writer
Custard or Cheesecake? — Exploring the Loring's Marriage in Juno
Mika AM
"Hillbilly Elegy" (2020) and the Problem of Profoundness
Dr. Thomas J. West III in Screenology
The Utah Monolith: Showing the Hope and Power of "2001"
Barry Vacker


text:
Discover Britain's leading independent schools
@attainguide /attainguide
Search results: 'Leweston School'
There are 5 pages about 'Leweston School'. You can browse profiles of individual independent schools using the regional links above, find the latest news and feature articles, or search for a specific page.
Dorset Fire and Rescue visit Leweston Prep
07/10 : Leweston Prep were lucky enough to have a visit from Dorset & Wiltshire Fire and Rescue, along with their fire engine. The pupils spent the morning with the Dorset Fire prevention team, learning about fire safety and what measures they can take to ensure safety for themselves, as well as others.
Leweston's Equestrian Team become National Champions
10/06 : Leweston School's Equestrian Team were victorious at the 'All England Jumping Course', Hickstead, for the NSEA Eventers Challenge, National County Dressage and Showjumping Championships
School Profile:
Leweston School
Leweston School is an independent day and boarding school for boys and girls aged 3 months to 18 in Sherborne, Dorset.
Athletes from Leweston selected for GB Laser Run for European Championships
03/05 : Five athletes from Leweston School – Izzy, Reuben, Katrina, Charlie and Archie – have been selected for the Great Britain Laser Run team for the European Championships.
Leweston comes together to help Ukraine
08/03 : Pupils at Leweston joined with the local community to offer donations to send to families in Ukraine. The school was a drop-off site for families to donate food, toiletries, medical equipment and children's clothing.
Results output is limited to 8 pages. Can't find a specific page? Please use the navigation above to browse to the relevant section or search for the specific page.
Copyright ©2006-2023 Chapel Studios Ltd. All rights reserved · ISSN 2045-6867 · Terms & Privacy


text:
Q: Unable to find javadoc command: The environment variable JAVA_HOME is not correctly set When I try to create my project's Javadoc in IntelliJ IDEA using Maven, the following error appears:
[ERROR] Failed to execute goal org.apache.maven.plugins:maven-javadoc-plugin:3.0.1:javadoc (default-cli) on project spotify-web-api-java: An error has occurred in Javadoc report generation: Unable to find javadoc command: The environment variable JAVA_HOME is not correctly set. -> [Help 1]

JAVA_HOME is correctly set in any console window I open though, as echo $JAVA_HOME confirms. Why isn't it in IntelliJ?

A: This is because IntelliJ's internal consoles use their own environment. You can set variables for Maven in the settings dialog under Build, Execution, Deployment > Build Tools > Maven > Runner > Environment variables. Add JAVA_HOME with whatever echo $JAVA_HOME returns in your usual terminal window as a value and Maven will be able to find the javadoc command!


Suzuki Slingshot is a bold and a comfortable bike with aerodynamic design and excellent frame work. Read on for its technical specifications, latest features and price.
A potential motor, bold styling and comfortable ride makes Suzuki Slingshot the powerful bike. The aerodynamic design of the vehicle with excellent frame work adds stylish appeal to it. This well configured bike is not only known for its looks but also for its great mileage and excellent performance. With all the prominent features into its credit Slingshot is best suited for Indian roads.
The new Slingshot has the engine with the displacement of 125cc. The four strokes, single cylinder, air cooled, SOHC engine of the bike follows the compact design and is a very powerful performer. The engine is intended to deliver the maximum power of about 8.5 bhp at 7500 rpm and offers the maximum torque of about 10 Nm at 3500 rpm.
The bold and sporty appearance of Slingshot is eye catching and irresistible. The front portion of the bike with headlamp cluster, stylish dashboard, stunning sticker and front cowl is major attraction of the vehicle. Adding to all these features the trendy alloy wheels, wide tires and sharp tail make the bike long even more fashionable. The broader step up seat of the vehicle is other noted factor when it comes to comfort.
Riding a Slingshot is a thrilling experience. With the help of its powerful engine the bike reaches the higher speed without much vibration. Even at the higher speed the vehicle is completely under the control of rider and for this the larger wheelbase of the bike is the main reason. The drum braking system both at the front and rear helps to quickly apply the brake without any unexpected risk.
Slingshot is a good choice for people who look for fuel economy. The bike gives the impressive mileage of about 60kmpl.
Slingshot is available in four different colors namely metallic mustard yellow, candy antares red, pearl nebular black and metallic fox orange. The ex-showroom price of this vehicle is about Rs. 46,747.


Our base is equipped with printing and bookbinding equipment that enables fast and efficient manufacturing in small and large circulations of various types of printed materials as well as the subsequent finishing processes – folding, creasing, punching, sewing, placing of metal comb, making of hardcover, stacking, rounding corners, placing caps, needle perforating, laminating and more.
Single sheet, multiple sheets and operating calendars, calendar notebooks, calendar pyramids and more. We use a wide variety of papers, offset, chrome, spectacular, recycled or FSC certified.
Optional: full and selective varnishing, laminating, stacking.
Special services: local aroma lacquer. You can choose from over 150 basic flavors. Possibility to order personalized flavor.


Xiaomi today finally launched their two models Mi A2 and Mi A2 Lite through a special event in Madrid, Spain. The two models will now be ready to compete with other similar models already available in the market. You will now have more options from which you can select your choice. This is the second edition of the stock Android phones by Xiaomi and it is looking much better than the first edition of the same series. The first model Mi A2 is a powerful device and Mi A2 Lite does not disappoint with its performance. You may find Mi A2 Lite much superior to the competitors.
Xiaomi Mi A2 has a 5.99-inch screen with 18:9 aspect ratio. The full HD+ display is going to be highly beneficial and you can comfortably watch your favourite videos without any difficulty. The Aluminium body design of this gadget gives the premium appearance. The company is offering the Arc Design to make the gadget unique in its category. There is no doubt that this smartphone is much better than the previous edition. It works with Android One and it has a fingerprint sensor also on the rear side. The smartphone is based on Qualcomm Snapdragon 660 processor. You will also find the AI engine here which will make the gadget special in its segment.
It is easily understandable that Xiaomi is regularly working to make their models better with every new edition. Many people were not satisfied with the camera Mi A1 but the condition is not the same this time. People were not expecting that photography can become one of the strongest points in Mi A2. This smartphone has a dual camera setup with 20MP+12MP lenses. You will find f/1.75 aperture here and you can choose the lens as per the requirement. LED Flash is powerful enough to give you the clear images. The company has included an influential 20MP secondary camera. The camera has the power of AI features. Therefore you will get the full value for money.
There are three variants of Mi A2. Therefore you can easily choose the model of your choice. The available memory options are 4GB RAM+32GB internal memory, 4GB RAM+64GB internal memory, and 6GB RAM+128GB internal memory. Xiaomi has not included any microSD slot here. The weight of the gadget is 166 grams and the thickness is 7.3 mm. It has the pixel density of 403ppi and the resolutions are 2160*1080 pixels. You will find 3010 mAh battery and the starting price is €250 here.
Now if we talk about Mi A2 Lite, then you will find a full HD+ display here with the screen size of 5.84-inch. The smartphone has a 19:9 aspect ratio and the resolutions are 2280*1080 pixels. The gadget has a Qualcomm Snapdragon 625 processor and it has 4000 mAh battery. The gadget will have two variants. The available options will be 3GB RAM+32GB internal capacity and 4GB RAM+64GB internal capacity. The starting price of Mi A2 Lite is €180 only.


Hiring an interior decorator saves money in the long run by helping business and homeowners avoid costly and unappealing décor and design blunders guised as trending investments. By providing our clients with valuable resources, we guarantee the acquirement of quality products. An interior decorator delivers instant access to a number of services like: handpicking and coordinating color, lighting, furniture, fixtures, material and measurements. These details not only add value to any Royal Oak property, but transforms them into a truly satisfying space to live and work in.
Creating a beautiful environment is conducive to your wellbeing and productivity. You'll feel calmer because your home or office will not only be in order it'll look great too. Beautiful spaces work as a type of therapy. Certain colors, layouts and patterns can even increase work productivity, reduce stress and help with abnormal sleeping patterns, it can even improve your eating habits.
When is the best time to call an interior decorator?
Usually the best time to contact decor professionals is the moment you decide to buy, sell or renovate your home or commercial Royal Oak property. Business owners and professionals usually consult with an interior decorator to help formulate an aesthetic plan; or when they are unsure of the decorating process and are in need of professional guidance.
Settling on the type of style you want for your property is a lot of work and can be confusing for anyone. Interior decorators will help you make the right choices among a variety of styles. When it comes to trends for home and office interior décor, a quality decorator will make sure to update any old and outdated stylings. Another good time to consult with an interior decorator would be when a commercial or residential property is in need of minor remodeling help. Like: new window treatments, floor coverings, furniture or accessories. An interior decorator is much more cost effective and ensures exceptional results. We really know how to bring a room together, no matter what your style is, we can make it work!
What can I expect during the first visit from a Interior Style Decorating Studio, LLC decorator?
How much will it cost to redecorate my home or commercial property with Interior Style Decorating Studio, LLC?
It all starts with a phone call and a complimentary one-hour initial consultation to discuss your ideas. Most décor ideas can be adapted to almost any budget. Typically, Interior Style Decorating Studio, LLC fees are a combination of a fixed rate and an hourly fee depending on the services you require. Call us for more information and to discuss your project. We are looking forward to working with you in creating your dream home or ideal work setting!


text:
from collections import deque
from datetime import datetime
import operator
import re

import numpy as np
import pytest
import pytz

import pandas as pd
from pandas import DataFrame, MultiIndex, Series
import pandas._testing as tm
import pandas.core.common as com
from pandas.tests.frame.common import _check_mixed_float, _check_mixed_int

# -------------------------------------------------------------------
# Comparisons

class TestFrameComparisons:
    # Specifically _not_ flex-comparisons

    def test_frame_in_list(self):
        # GH#12689 this should raise at the DataFrame level, not blocks
        df = pd.DataFrame(np.random.randn(6, 4), columns=list("ABCD"))
        msg = "The truth value of a DataFrame is ambiguous"
        with pytest.raises(ValueError, match=msg):
            df in [None]

    def test_comparison_invalid(self):
        def check(df, df2):

            for (x, y) in [(df, df2), (df2, df)]:
                # we expect the result to match Series comparisons for
                # == and !=, inequalities should raise
                result = x == y
                expected = pd.DataFrame(
                    {col: x[col] == y[col] for col in x.columns},
                    index=x.index,
                    columns=x.columns,
                )
                tm.assert_frame_equal(result, expected)

                result = x != y
                expected = pd.DataFrame(
                    {col: x[col] != y[col] for col in x.columns},
                    index=x.index,
                    columns=x.columns,
                )
                tm.assert_frame_equal(result, expected)

                msgs = [
                    r"Invalid comparison between dtype=datetime64\[ns\] and ndarray",
                    "invalid type promotion",
                ]
                msg = "|".join(msgs)
                with pytest.raises(TypeError, match=msg):
                    x >= y
                with pytest.raises(TypeError, match=msg):
                    x > y
                with pytest.raises(TypeError, match=msg):
                    x < y
                with pytest.raises(TypeError, match=msg):
                    x <= y

        # GH4968
        # invalid date/int comparisons
        df = pd.DataFrame(np.random.randint(10, size=(10, 1)), columns=["a"])
        df["dates"] = pd.date_range("20010101", periods=len(df))

        df2 = df.copy()
        df2["dates"] = df["a"]
        check(df, df2)

        df = pd.DataFrame(np.random.randint(10, size=(10, 2)), columns=["a", "b"])
        df2 = pd.DataFrame(
            {
                "a": pd.date_range("20010101", periods=len(df)),
                "b": pd.date_range("20100101", periods=len(df)),
            }
        )
        check(df, df2)

    def test_timestamp_compare(self):
        # make sure we can compare Timestamps on the right AND left hand side
        # GH#4982
        df = pd.DataFrame(
            {
                "dates1": pd.date_range("20010101", periods=10),
                "dates2": pd.date_range("20010102", periods=10),
                "intcol": np.random.randint(1000000000, size=10),
                "floatcol": np.random.randn(10),
                "stringcol": list(tm.rands(10)),
            }
        )
        df.loc[np.random.rand(len(df)) > 0.5, "dates2"] = pd.NaT
        ops = {"gt": "lt", "lt": "gt", "ge": "le", "le": "ge", "eq": "eq", "ne": "ne"}

        for left, right in ops.items():
            left_f = getattr(operator, left)
            right_f = getattr(operator, right)

            # no nats
            if left in ["eq", "ne"]:
                expected = left_f(df, pd.Timestamp("20010109"))
                result = right_f(pd.Timestamp("20010109"), df)
                tm.assert_frame_equal(result, expected)
            else:
                msg = (
                    "'(<|>)=?' not supported between "
                    "instances of 'numpy.ndarray' and 'Timestamp'"
                )
                with pytest.raises(TypeError, match=msg):
                    left_f(df, pd.Timestamp("20010109"))
                with pytest.raises(TypeError, match=msg):
                    right_f(pd.Timestamp("20010109"), df)
            # nats
            expected = left_f(df, pd.Timestamp("nat"))
            result = right_f(pd.Timestamp("nat"), df)
            tm.assert_frame_equal(result, expected)

    def test_mixed_comparison(self):
        # GH#13128, GH#22163 != datetime64 vs non-dt64 should be False,
        # not raise TypeError
        # (this appears to be fixed before GH#22163, not sure when)
        df = pd.DataFrame([["1989-08-01", 1], ["1989-08-01", 2]])
        other = pd.DataFrame([["a", "b"], ["c", "d"]])

        result = df == other
        assert not result.any().any()

        result = df != other
        assert result.all().all()

    def test_df_boolean_comparison_error(self):
        # GH#4576, GH#22880
        # comparing DataFrame against list/tuple with len(obj) matching
        #  len(df.columns) is supported as of GH#22800
        df = pd.DataFrame(np.arange(6).reshape((3, 2)))

        expected = pd.DataFrame([[False, False], [True, False], [False, False]])

        result = df == (2, 2)
        tm.assert_frame_equal(result, expected)

        result = df == [2, 2]
        tm.assert_frame_equal(result, expected)

    def test_df_float_none_comparison(self):
        df = pd.DataFrame(
            np.random.randn(8, 3), index=range(8), columns=["A", "B", "C"]
        )

        result = df.__eq__(None)
        assert not result.any().any()

    def test_df_string_comparison(self):
        df = pd.DataFrame([{"a": 1, "b": "foo"}, {"a": 2, "b": "bar"}])
        mask_a = df.a > 1
        tm.assert_frame_equal(df[mask_a], df.loc[1:1, :])
        tm.assert_frame_equal(df[-mask_a], df.loc[0:0, :])

        mask_b = df.b == "foo"
        tm.assert_frame_equal(df[mask_b], df.loc[0:0, :])
        tm.assert_frame_equal(df[-mask_b], df.loc[1:1, :])

class TestFrameFlexComparisons:
    # TODO: test_bool_flex_frame needs a better name
    def test_bool_flex_frame(self):
        data = np.random.randn(5, 3)
        other_data = np.random.randn(5, 3)
        df = pd.DataFrame(data)
        other = pd.DataFrame(other_data)
        ndim_5 = np.ones(df.shape + (1, 3))

        # Unaligned
        def _check_unaligned_frame(meth, op, df, other):
            part_o = other.loc[3:, 1:].copy()
            rs = meth(part_o)
            xp = op(df, part_o.reindex(index=df.index, columns=df.columns))
            tm.assert_frame_equal(rs, xp)

        # DataFrame
        assert df.eq(df).values.all()
        assert not df.ne(df).values.any()
        for op in ["eq", "ne", "gt", "lt", "ge", "le"]:
            f = getattr(df, op)
            o = getattr(operator, op)
            # No NAs
            tm.assert_frame_equal(f(other), o(df, other))
            _check_unaligned_frame(f, o, df, other)
            # ndarray
            tm.assert_frame_equal(f(other.values), o(df, other.values))
            # scalar
            tm.assert_frame_equal(f(0), o(df, 0))
            # NAs
            msg = "Unable to coerce to Series/DataFrame"
            tm.assert_frame_equal(f(np.nan), o(df, np.nan))
            with pytest.raises(ValueError, match=msg):
                f(ndim_5)

        # Series
        def _test_seq(df, idx_ser, col_ser):
            idx_eq = df.eq(idx_ser, axis=0)
            col_eq = df.eq(col_ser)
            idx_ne = df.ne(idx_ser, axis=0)
            col_ne = df.ne(col_ser)
            tm.assert_frame_equal(col_eq, df == pd.Series(col_ser))
            tm.assert_frame_equal(col_eq, -col_ne)
            tm.assert_frame_equal(idx_eq, -idx_ne)
            tm.assert_frame_equal(idx_eq, df.T.eq(idx_ser).T)
            tm.assert_frame_equal(col_eq, df.eq(list(col_ser)))
            tm.assert_frame_equal(idx_eq, df.eq(pd.Series(idx_ser), axis=0))
            tm.assert_frame_equal(idx_eq, df.eq(list(idx_ser), axis=0))

            idx_gt = df.gt(idx_ser, axis=0)
            col_gt = df.gt(col_ser)
            idx_le = df.le(idx_ser, axis=0)
            col_le = df.le(col_ser)

            tm.assert_frame_equal(col_gt, df > pd.Series(col_ser))
            tm.assert_frame_equal(col_gt, -col_le)
            tm.assert_frame_equal(idx_gt, -idx_le)
            tm.assert_frame_equal(idx_gt, df.T.gt(idx_ser).T)

            idx_ge = df.ge(idx_ser, axis=0)
            col_ge = df.ge(col_ser)
            idx_lt = df.lt(idx_ser, axis=0)
            col_lt = df.lt(col_ser)
            tm.assert_frame_equal(col_ge, df >= pd.Series(col_ser))
            tm.assert_frame_equal(col_ge, -col_lt)
            tm.assert_frame_equal(idx_ge, -idx_lt)
            tm.assert_frame_equal(idx_ge, df.T.ge(idx_ser).T)

        idx_ser = pd.Series(np.random.randn(5))
        col_ser = pd.Series(np.random.randn(3))
        _test_seq(df, idx_ser, col_ser)

        # list/tuple
        _test_seq(df, idx_ser.values, col_ser.values)

        # NA
        df.loc[0, 0] = np.nan
        rs = df.eq(df)
        assert not rs.loc[0, 0]
        rs = df.ne(df)
        assert rs.loc[0, 0]
        rs = df.gt(df)
        assert not rs.loc[0, 0]
        rs = df.lt(df)
        assert not rs.loc[0, 0]
        rs = df.ge(df)
        assert not rs.loc[0, 0]
        rs = df.le(df)
        assert not rs.loc[0, 0]

    def test_bool_flex_frame_complex_dtype(self):
        # complex
        arr = np.array([np.nan, 1, 6, np.nan])
        arr2 = np.array([2j, np.nan, 7, None])
        df = pd.DataFrame({"a": arr})
        df2 = pd.DataFrame({"a": arr2})

        msg = "|".join(
            [
                "'>' not supported between instances of '.*' and 'complex'",
                r"unorderable types: .*complex\(\)",  # PY35
            ]
        )
        with pytest.raises(TypeError, match=msg):
            # inequalities are not well-defined for complex numbers
            df.gt(df2)
        with pytest.raises(TypeError, match=msg):
            # regression test that we get the same behavior for Series
            df["a"].gt(df2["a"])
        with pytest.raises(TypeError, match=msg):
            # Check that we match numpy behavior here
            df.values > df2.values

        rs = df.ne(df2)
        assert rs.values.all()

        arr3 = np.array([2j, np.nan, None])
        df3 = pd.DataFrame({"a": arr3})

        with pytest.raises(TypeError, match=msg):
            # inequalities are not well-defined for complex numbers
            df3.gt(2j)
        with pytest.raises(TypeError, match=msg):
            # regression test that we get the same behavior for Series
            df3["a"].gt(2j)
        with pytest.raises(TypeError, match=msg):
            # Check that we match numpy behavior here
            df3.values > 2j

    def test_bool_flex_frame_object_dtype(self):
        # corner, dtype=object
        df1 = pd.DataFrame({"col": ["foo", np.nan, "bar"]})
        df2 = pd.DataFrame({"col": ["foo", datetime.now(), "bar"]})
        result = df1.ne(df2)
        exp = pd.DataFrame({"col": [False, True, False]})
        tm.assert_frame_equal(result, exp)

    def test_flex_comparison_nat(self):
        # GH 15697, GH 22163 df.eq(pd.NaT) should behave like df == pd.NaT,
        # and _definitely_ not be NaN
        df = pd.DataFrame([pd.NaT])

        result = df == pd.NaT
        # result.iloc[0, 0] is a np.bool_ object
        assert result.iloc[0, 0].item() is False

        result = df.eq(pd.NaT)
        assert result.iloc[0, 0].item() is False

        result = df != pd.NaT
        assert result.iloc[0, 0].item() is True

        result = df.ne(pd.NaT)
        assert result.iloc[0, 0].item() is True

    @pytest.mark.parametrize("opname", ["eq", "ne", "gt", "lt", "ge", "le"])
    def test_df_flex_cmp_constant_return_types(self, opname):
        # GH 15077, non-empty DataFrame
        df = pd.DataFrame({"x": [1, 2, 3], "y": [1.0, 2.0, 3.0]})
        const = 2

        result = getattr(df, opname)(const).dtypes.value_counts()
        tm.assert_series_equal(result, pd.Series([2], index=[np.dtype(bool)]))

    @pytest.mark.parametrize("opname", ["eq", "ne", "gt", "lt", "ge", "le"])
    def test_df_flex_cmp_constant_return_types_empty(self, opname):
        # GH 15077 empty DataFrame
        df = pd.DataFrame({"x": [1, 2, 3], "y": [1.0, 2.0, 3.0]})
        const = 2

        empty = df.iloc[:0]
        result = getattr(empty, opname)(const).dtypes.value_counts()
        tm.assert_series_equal(result, pd.Series([2], index=[np.dtype(bool)]))

    def test_df_flex_cmp_ea_dtype_with_ndarray_series(self):
        ii = pd.IntervalIndex.from_breaks([1, 2, 3])
        df = pd.DataFrame({"A": ii, "B": ii})

        ser = pd.Series([0, 0])
        res = df.eq(ser, axis=0)

        expected = pd.DataFrame({"A": [False, False], "B": [False, False]})
        tm.assert_frame_equal(res, expected)

        ser2 = pd.Series([1, 2], index=["A", "B"])
        res2 = df.eq(ser2, axis=1)
        tm.assert_frame_equal(res2, expected)

# -------------------------------------------------------------------
# Arithmetic

class TestFrameFlexArithmetic:
    def test_floordiv_axis0(self):
        # make sure we df.floordiv(ser, axis=0) matches column-wise result
        arr = np.arange(3)
        ser = pd.Series(arr)
        df = pd.DataFrame({"A": ser, "B": ser})

        result = df.floordiv(ser, axis=0)

        expected = pd.DataFrame({col: df[col] // ser for col in df.columns})

        tm.assert_frame_equal(result, expected)

        result2 = df.floordiv(ser.values, axis=0)
        tm.assert_frame_equal(result2, expected)

    @pytest.mark.slow
    @pytest.mark.parametrize("opname", ["floordiv", "pow"])
    def test_floordiv_axis0_numexpr_path(self, opname):
        # case that goes through numexpr and has to fall back to masked_arith_op
        op = getattr(operator, opname)

        arr = np.arange(10 ** 6).reshape(100, -1)
        df = pd.DataFrame(arr)
        df["C"] = 1.0

        ser = df[0]
        result = getattr(df, opname)(ser, axis=0)

        expected = pd.DataFrame({col: op(df[col], ser) for col in df.columns})
        tm.assert_frame_equal(result, expected)

        result2 = getattr(df, opname)(ser.values, axis=0)
        tm.assert_frame_equal(result2, expected)

    def test_df_add_td64_columnwise(self):
        # GH 22534 Check that column-wise addition broadcasts correctly
        dti = pd.date_range("2016-01-01", periods=10)
        tdi = pd.timedelta_range("1", periods=10)
        tser = pd.Series(tdi)
        df = pd.DataFrame({0: dti, 1: tdi})

        result = df.add(tser, axis=0)
        expected = pd.DataFrame({0: dti + tdi, 1: tdi + tdi})
        tm.assert_frame_equal(result, expected)

    def test_df_add_flex_filled_mixed_dtypes(self):
        # GH 19611
        dti = pd.date_range("2016-01-01", periods=3)
        ser = pd.Series(["1 Day", "NaT", "2 Days"], dtype="timedelta64[ns]")
        df = pd.DataFrame({"A": dti, "B": ser})
        other = pd.DataFrame({"A": ser, "B": ser})
        fill = pd.Timedelta(days=1).to_timedelta64()
        result = df.add(other, fill_value=fill)

        expected = pd.DataFrame(
            {
                "A": pd.Series(
                    ["2016-01-02", "2016-01-03", "2016-01-05"], dtype="datetime64[ns]"
                ),
                "B": ser * 2,
            }
        )
        tm.assert_frame_equal(result, expected)

    def test_arith_flex_frame(
        self, all_arithmetic_operators, float_frame, mixed_float_frame
    ):
        # one instance of parametrized fixture
        op = all_arithmetic_operators

        def f(x, y):
            # r-versions not in operator-stdlib; get op without "r" and invert
            if op.startswith("__r"):
                return getattr(operator, op.replace("__r", "__"))(y, x)
            return getattr(operator, op)(x, y)

        result = getattr(float_frame, op)(2 * float_frame)
        expected = f(float_frame, 2 * float_frame)
        tm.assert_frame_equal(result, expected)

        # vs mix float
        result = getattr(mixed_float_frame, op)(2 * mixed_float_frame)
        expected = f(mixed_float_frame, 2 * mixed_float_frame)
        tm.assert_frame_equal(result, expected)
        _check_mixed_float(result, dtype=dict(C=None))

    @pytest.mark.parametrize("op", ["__add__", "__sub__", "__mul__"])
    def test_arith_flex_frame_mixed(
        self, op, int_frame, mixed_int_frame, mixed_float_frame
    ):
        f = getattr(operator, op)

        # vs mix int
        result = getattr(mixed_int_frame, op)(2 + mixed_int_frame)
        expected = f(mixed_int_frame, 2 + mixed_int_frame)

        # no overflow in the uint
        dtype = None
        if op in ["__sub__"]:
            dtype = dict(B="uint64", C=None)
        elif op in ["__add__", "__mul__"]:
            dtype = dict(C=None)
        tm.assert_frame_equal(result, expected)
        _check_mixed_int(result, dtype=dtype)

        # vs mix float
        result = getattr(mixed_float_frame, op)(2 * mixed_float_frame)
        expected = f(mixed_float_frame, 2 * mixed_float_frame)
        tm.assert_frame_equal(result, expected)
        _check_mixed_float(result, dtype=dict(C=None))

        # vs plain int
        result = getattr(int_frame, op)(2 * int_frame)
        expected = f(int_frame, 2 * int_frame)
        tm.assert_frame_equal(result, expected)

    def test_arith_flex_frame_raise(self, all_arithmetic_operators, float_frame):
        # one instance of parametrized fixture
        op = all_arithmetic_operators

        # Check that arrays with dim >= 3 raise
        for dim in range(3, 6):
            arr = np.ones((1,) * dim)
            msg = "Unable to coerce to Series/DataFrame"
            with pytest.raises(ValueError, match=msg):
                getattr(float_frame, op)(arr)

    def test_arith_flex_frame_corner(self, float_frame):

        const_add = float_frame.add(1)
        tm.assert_frame_equal(const_add, float_frame + 1)

        # corner cases
        result = float_frame.add(float_frame[:0])
        tm.assert_frame_equal(result, float_frame * np.nan)

        result = float_frame[:0].add(float_frame)
        tm.assert_frame_equal(result, float_frame * np.nan)

        with pytest.raises(NotImplementedError, match="fill_value"):
            float_frame.add(float_frame.iloc[0], fill_value=3)

        with pytest.raises(NotImplementedError, match="fill_value"):
            float_frame.add(float_frame.iloc[0], axis="index", fill_value=3)

    def test_arith_flex_series(self, simple_frame):
        df = simple_frame

        row = df.xs("a")
        col = df["two"]
        # after arithmetic refactor, add truediv here
        ops = ["add", "sub", "mul", "mod"]
        for op in ops:
            f = getattr(df, op)
            op = getattr(operator, op)
            tm.assert_frame_equal(f(row), op(df, row))
            tm.assert_frame_equal(f(col, axis=0), op(df.T, col).T)

        # special case for some reason
        tm.assert_frame_equal(df.add(row, axis=None), df + row)

        # cases which will be refactored after big arithmetic refactor
        tm.assert_frame_equal(df.div(row), df / row)
        tm.assert_frame_equal(df.div(col, axis=0), (df.T / col).T)

        # broadcasting issue in GH 7325
        df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype="int64")
        expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
        result = df.div(df[0], axis="index")
        tm.assert_frame_equal(result, expected)

        df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype="float64")
        expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
        result = df.div(df[0], axis="index")
        tm.assert_frame_equal(result, expected)

    def test_arith_flex_zero_len_raises(self):
        # GH 19522 passing fill_value to frame flex arith methods should
        # raise even in the zero-length special cases
        ser_len0 = pd.Series([], dtype=object)
        df_len0 = pd.DataFrame(columns=["A", "B"])
        df = pd.DataFrame([[1, 2], [3, 4]], columns=["A", "B"])

        with pytest.raises(NotImplementedError, match="fill_value"):
            df.add(ser_len0, fill_value="E")

        with pytest.raises(NotImplementedError, match="fill_value"):
            df_len0.sub(df["A"], axis=None, fill_value=3)

    def test_flex_add_scalar_fill_value(self):
        # GH#12723
        dat = np.array([0, 1, np.nan, 3, 4, 5], dtype="float")
        df = pd.DataFrame({"foo": dat}, index=range(6))

        exp = df.fillna(0).add(2)
        res = df.add(2, fill_value=0)
        tm.assert_frame_equal(res, exp)

class TestFrameArithmetic:
    def test_td64_op_nat_casting(self):
        # Make sure we don't accidentally treat timedelta64(NaT) as datetime64
        #  when calling dispatch_to_series in DataFrame arithmetic
        ser = pd.Series(["NaT", "NaT"], dtype="timedelta64[ns]")
        df = pd.DataFrame([[1, 2], [3, 4]])

        result = df * ser
        expected = pd.DataFrame({0: ser, 1: ser})
        tm.assert_frame_equal(result, expected)

    def test_df_add_2d_array_rowlike_broadcasts(self):
        # GH#23000
        arr = np.arange(6).reshape(3, 2)
        df = pd.DataFrame(arr, columns=[True, False], index=["A", "B", "C"])

        rowlike = arr[[1], :]  # shape --> (1, ncols)
        assert rowlike.shape == (1, df.shape[1])

        expected = pd.DataFrame(
            [[2, 4], [4, 6], [6, 8]],
            columns=df.columns,
            index=df.index,
            # specify dtype explicitly to avoid failing
            # on 32bit builds
            dtype=arr.dtype,
        )
        result = df + rowlike
        tm.assert_frame_equal(result, expected)
        result = rowlike + df
        tm.assert_frame_equal(result, expected)

    def test_df_add_2d_array_collike_broadcasts(self):
        # GH#23000
        arr = np.arange(6).reshape(3, 2)
        df = pd.DataFrame(arr, columns=[True, False], index=["A", "B", "C"])

        collike = arr[:, [1]]  # shape --> (nrows, 1)
        assert collike.shape == (df.shape[0], 1)

        expected = pd.DataFrame(
            [[1, 2], [5, 6], [9, 10]],
            columns=df.columns,
            index=df.index,
            # specify dtype explicitly to avoid failing
            # on 32bit builds
            dtype=arr.dtype,
        )
        result = df + collike
        tm.assert_frame_equal(result, expected)
        result = collike + df
        tm.assert_frame_equal(result, expected)

    def test_df_arith_2d_array_rowlike_broadcasts(self, all_arithmetic_operators):
        # GH#23000
        opname = all_arithmetic_operators

        arr = np.arange(6).reshape(3, 2)
        df = pd.DataFrame(arr, columns=[True, False], index=["A", "B", "C"])

        rowlike = arr[[1], :]  # shape --> (1, ncols)
        assert rowlike.shape == (1, df.shape[1])

        exvals = [
            getattr(df.loc["A"], opname)(rowlike.squeeze()),
            getattr(df.loc["B"], opname)(rowlike.squeeze()),
            getattr(df.loc["C"], opname)(rowlike.squeeze()),
        ]

        expected = pd.DataFrame(exvals, columns=df.columns, index=df.index)

        result = getattr(df, opname)(rowlike)
        tm.assert_frame_equal(result, expected)

    def test_df_arith_2d_array_collike_broadcasts(self, all_arithmetic_operators):
        # GH#23000
        opname = all_arithmetic_operators

        arr = np.arange(6).reshape(3, 2)
        df = pd.DataFrame(arr, columns=[True, False], index=["A", "B", "C"])

        collike = arr[:, [1]]  # shape --> (nrows, 1)
        assert collike.shape == (df.shape[0], 1)

        exvals = {
            True: getattr(df[True], opname)(collike.squeeze()),
            False: getattr(df[False], opname)(collike.squeeze()),
        }

        dtype = None
        if opname in ["__rmod__", "__rfloordiv__"]:
            # Series ops may return mixed int/float dtypes in cases where
            #   DataFrame op will return all-float.  So we upcast `expected`
            dtype = np.common_type(*[x.values for x in exvals.values()])

        expected = pd.DataFrame(exvals, columns=df.columns, index=df.index, dtype=dtype)

        result = getattr(df, opname)(collike)
        tm.assert_frame_equal(result, expected)

    def test_df_bool_mul_int(self):
        # GH 22047, GH 22163 multiplication by 1 should result in int dtype,
        # not object dtype
        df = pd.DataFrame([[False, True], [False, False]])
        result = df * 1

        # On appveyor this comes back as np.int32 instead of np.int64,
        # so we check dtype.kind instead of just dtype
        kinds = result.dtypes.apply(lambda x: x.kind)
        assert (kinds == "i").all()

        result = 1 * df
        kinds = result.dtypes.apply(lambda x: x.kind)
        assert (kinds == "i").all()

    def test_arith_mixed(self):

        left = pd.DataFrame({"A": ["a", "b", "c"], "B": [1, 2, 3]})

        result = left + left
        expected = pd.DataFrame({"A": ["aa", "bb", "cc"], "B": [2, 4, 6]})
        tm.assert_frame_equal(result, expected)

    def test_arith_getitem_commute(self):
        df = pd.DataFrame({"A": [1.1, 3.3], "B": [2.5, -3.9]})

        def _test_op(df, op):
            result = op(df, 1)

            if not df.columns.is_unique:
                raise ValueError("Only unique columns supported by this test")

            for col in result.columns:
                tm.assert_series_equal(result[col], op(df[col], 1))

        _test_op(df, operator.add)
        _test_op(df, operator.sub)
        _test_op(df, operator.mul)
        _test_op(df, operator.truediv)
        _test_op(df, operator.floordiv)
        _test_op(df, operator.pow)

        _test_op(df, lambda x, y: y + x)
        _test_op(df, lambda x, y: y - x)
        _test_op(df, lambda x, y: y * x)
        _test_op(df, lambda x, y: y / x)
        _test_op(df, lambda x, y: y ** x)

        _test_op(df, lambda x, y: x + y)
        _test_op(df, lambda x, y: x - y)
        _test_op(df, lambda x, y: x * y)
        _test_op(df, lambda x, y: x / y)
        _test_op(df, lambda x, y: x ** y)

    @pytest.mark.parametrize(
        "values", [[1, 2], (1, 2), np.array([1, 2]), range(1, 3), deque([1, 2])]
    )
    def test_arith_alignment_non_pandas_object(self, values):
        # GH#17901
        df = pd.DataFrame({"A": [1, 1], "B": [1, 1]})
        expected = pd.DataFrame({"A": [2, 2], "B": [3, 3]})
        result = df + values
        tm.assert_frame_equal(result, expected)

    def test_arith_non_pandas_object(self):
        df = pd.DataFrame(
            np.arange(1, 10, dtype="f8").reshape(3, 3),
            columns=["one", "two", "three"],
            index=["a", "b", "c"],
        )

        val1 = df.xs("a").values
        added = pd.DataFrame(df.values + val1, index=df.index, columns=df.columns)
        tm.assert_frame_equal(df + val1, added)

        added = pd.DataFrame((df.values.T + val1).T, index=df.index, columns=df.columns)
        tm.assert_frame_equal(df.add(val1, axis=0), added)

        val2 = list(df["two"])

        added = pd.DataFrame(df.values + val2, index=df.index, columns=df.columns)
        tm.assert_frame_equal(df + val2, added)

        added = pd.DataFrame((df.values.T + val2).T, index=df.index, columns=df.columns)
        tm.assert_frame_equal(df.add(val2, axis="index"), added)

        val3 = np.random.rand(*df.shape)
        added = pd.DataFrame(df.values + val3, index=df.index, columns=df.columns)
        tm.assert_frame_equal(df.add(val3), added)

    def test_operations_with_interval_categories_index(self, all_arithmetic_operators):
        # GH#27415
        op = all_arithmetic_operators
        ind = pd.CategoricalIndex(pd.interval_range(start=0.0, end=2.0))
        data = [1, 2]
        df = pd.DataFrame([data], columns=ind)
        num = 10
        result = getattr(df, op)(num)
        expected = pd.DataFrame([[getattr(n, op)(num) for n in data]], columns=ind)
        tm.assert_frame_equal(result, expected)

    def test_frame_with_frame_reindex(self):
        # GH#31623
        df = pd.DataFrame(
            {
                "foo": [pd.Timestamp("2019"), pd.Timestamp("2020")],
                "bar": [pd.Timestamp("2018"), pd.Timestamp("2021")],
            },
            columns=["foo", "bar"],
        )
        df2 = df[["foo"]]

        result = df - df2

        expected = pd.DataFrame(
            {"foo": [pd.Timedelta(0), pd.Timedelta(0)], "bar": [np.nan, np.nan]},
            columns=["bar", "foo"],
        )
        tm.assert_frame_equal(result, expected)

def test_frame_with_zero_len_series_corner_cases():
    # GH#28600
    # easy all-float case
    df = pd.DataFrame(np.random.randn(6).reshape(3, 2), columns=["A", "B"])
    ser = pd.Series(dtype=np.float64)

    result = df + ser
    expected = pd.DataFrame(df.values * np.nan, columns=df.columns)
    tm.assert_frame_equal(result, expected)

    result = df == ser
    expected = pd.DataFrame(False, index=df.index, columns=df.columns)
    tm.assert_frame_equal(result, expected)

    # non-float case should not raise on comparison
    df2 = pd.DataFrame(df.values.view("M8[ns]"), columns=df.columns)
    result = df2 == ser
    expected = pd.DataFrame(False, index=df.index, columns=df.columns)
    tm.assert_frame_equal(result, expected)

def test_zero_len_frame_with_series_corner_cases():
    # GH#28600
    df = pd.DataFrame(columns=["A", "B"], dtype=np.float64)
    ser = pd.Series([1, 2], index=["A", "B"])

    result = df + ser
    expected = df
    tm.assert_frame_equal(result, expected)

def test_frame_single_columns_object_sum_axis_1():
    # GH 13758
    data = {
        "One": pd.Series(["A", 1.2, np.nan]),
    }
    df = pd.DataFrame(data)
    result = df.sum(axis=1)
    expected = pd.Series(["A", 1.2, 0])
    tm.assert_series_equal(result, expected)

# -------------------------------------------------------------------
# Unsorted
#  These arithmetic tests were previously in other files, eventually
#  should be parametrized and put into tests.arithmetic

class TestFrameArithmeticUnsorted:
    def test_frame_add_tz_mismatch_converts_to_utc(self):
        rng = pd.date_range("1/1/2011", periods=10, freq="H", tz="US/Eastern")
        df = pd.DataFrame(np.random.randn(len(rng)), index=rng, columns=["a"])

        df_moscow = df.tz_convert("Europe/Moscow")
        result = df + df_moscow
        assert result.index.tz is pytz.utc

        result = df_moscow + df
        assert result.index.tz is pytz.utc

    def test_align_frame(self):
        rng = pd.period_range("1/1/2000", "1/1/2010", freq="A")
        ts = pd.DataFrame(np.random.randn(len(rng), 3), index=rng)

        result = ts + ts[::2]
        expected = ts + ts
        expected.values[1::2] = np.nan
        tm.assert_frame_equal(result, expected)

        half = ts[::2]
        result = ts + half.take(np.random.permutation(len(half)))
        tm.assert_frame_equal(result, expected)

    @pytest.mark.parametrize(
        "op", [operator.add, operator.sub, operator.mul, operator.truediv]
    )
    def test_operators_none_as_na(self, op):
        df = DataFrame(
            {"col1": [2, 5.0, 123, None], "col2": [1, 2, 3, 4]}, dtype=object
        )

        # since filling converts dtypes from object, changed expected to be
        # object
        filled = df.fillna(np.nan)
        result = op(df, 3)
        expected = op(filled, 3).astype(object)
        expected[com.isna(expected)] = None
        tm.assert_frame_equal(result, expected)

        result = op(df, df)
        expected = op(filled, filled).astype(object)
        expected[com.isna(expected)] = None
        tm.assert_frame_equal(result, expected)

        result = op(df, df.fillna(7))
        tm.assert_frame_equal(result, expected)

        result = op(df.fillna(7), df)
        tm.assert_frame_equal(result, expected, check_dtype=False)

    @pytest.mark.parametrize("op,res", [("__eq__", False), ("__ne__", True)])
    # TODO: not sure what's correct here.
    @pytest.mark.filterwarnings("ignore:elementwise:FutureWarning")
    def test_logical_typeerror_with_non_valid(self, op, res, float_frame):
        # we are comparing floats vs a string
        result = getattr(float_frame, op)("foo")
        assert bool(result.all().all()) is res

    def test_binary_ops_align(self):

        # test aligning binary ops

        # GH 6681
        index = MultiIndex.from_product(
            [list("abc"), ["one", "two", "three"], [1, 2, 3]],
            names=["first", "second", "third"],
        )

        df = DataFrame(
            np.arange(27 * 3).reshape(27, 3),
            index=index,
            columns=["value1", "value2", "value3"],
        ).sort_index()

        idx = pd.IndexSlice
        for op in ["add", "sub", "mul", "div", "truediv"]:
            opa = getattr(operator, op, None)
            if opa is None:
                continue

            x = Series([1.0, 10.0, 100.0], [1, 2, 3])
            result = getattr(df, op)(x, level="third", axis=0)

            expected = pd.concat(
                [opa(df.loc[idx[:, :, i], :], v) for i, v in x.items()]
            ).sort_index()
            tm.assert_frame_equal(result, expected)

            x = Series([1.0, 10.0], ["two", "three"])
            result = getattr(df, op)(x, level="second", axis=0)

            expected = (
                pd.concat([opa(df.loc[idx[:, i], :], v) for i, v in x.items()])
                .reindex_like(df)
                .sort_index()
            )
            tm.assert_frame_equal(result, expected)

        # GH9463 (alignment level of dataframe with series)

        midx = MultiIndex.from_product([["A", "B"], ["a", "b"]])
        df = DataFrame(np.ones((2, 4), dtype="int64"), columns=midx)
        s = pd.Series({"a": 1, "b": 2})

        df2 = df.copy()
        df2.columns.names = ["lvl0", "lvl1"]
        s2 = s.copy()
        s2.index.name = "lvl1"

        # different cases of integer/string level names:
        res1 = df.mul(s, axis=1, level=1)
        res2 = df.mul(s2, axis=1, level=1)
        res3 = df2.mul(s, axis=1, level=1)
        res4 = df2.mul(s2, axis=1, level=1)
        res5 = df2.mul(s, axis=1, level="lvl1")
        res6 = df2.mul(s2, axis=1, level="lvl1")

        exp = DataFrame(
            np.array([[1, 2, 1, 2], [1, 2, 1, 2]], dtype="int64"), columns=midx
        )

        for res in [res1, res2]:
            tm.assert_frame_equal(res, exp)

        exp.columns.names = ["lvl0", "lvl1"]
        for res in [res3, res4, res5, res6]:
            tm.assert_frame_equal(res, exp)

    def test_add_with_dti_mismatched_tzs(self):
        base = pd.DatetimeIndex(["2011-01-01", "2011-01-02", "2011-01-03"], tz="UTC")
        idx1 = base.tz_convert("Asia/Tokyo")[:2]
        idx2 = base.tz_convert("US/Eastern")[1:]

        df1 = DataFrame({"A": [1, 2]}, index=idx1)
        df2 = DataFrame({"A": [1, 1]}, index=idx2)
        exp = DataFrame({"A": [np.nan, 3, np.nan]}, index=base)
        tm.assert_frame_equal(df1 + df2, exp)

    def test_combineFrame(self, float_frame, mixed_float_frame, mixed_int_frame):
        frame_copy = float_frame.reindex(float_frame.index[::2])

        del frame_copy["D"]
        frame_copy["C"][:5] = np.nan

        added = float_frame + frame_copy

        indexer = added["A"].dropna().index
        exp = (float_frame["A"] * 2).copy()

        tm.assert_series_equal(added["A"].dropna(), exp.loc[indexer])

        exp.loc[~exp.index.isin(indexer)] = np.nan
        tm.assert_series_equal(added["A"], exp.loc[added["A"].index])

        assert np.isnan(added["C"].reindex(frame_copy.index)[:5]).all()

        # assert(False)

        assert np.isnan(added["D"]).all()

        self_added = float_frame + float_frame
        tm.assert_index_equal(self_added.index, float_frame.index)

        added_rev = frame_copy + float_frame
        assert np.isnan(added["D"]).all()
        assert np.isnan(added_rev["D"]).all()

        # corner cases

        # empty
        plus_empty = float_frame + DataFrame()
        assert np.isnan(plus_empty.values).all()

        empty_plus = DataFrame() + float_frame
        assert np.isnan(empty_plus.values).all()

        empty_empty = DataFrame() + DataFrame()
        assert empty_empty.empty

        # out of order
        reverse = float_frame.reindex(columns=float_frame.columns[::-1])

        tm.assert_frame_equal(reverse + float_frame, float_frame * 2)

        # mix vs float64, upcast
        added = float_frame + mixed_float_frame
        _check_mixed_float(added, dtype="float64")
        added = mixed_float_frame + float_frame
        _check_mixed_float(added, dtype="float64")

        # mix vs mix
        added = mixed_float_frame + mixed_float_frame
        _check_mixed_float(added, dtype=dict(C=None))

        # with int
        added = float_frame + mixed_int_frame
        _check_mixed_float(added, dtype="float64")

    def test_combine_series(
        self, float_frame, mixed_float_frame, mixed_int_frame, datetime_frame
    ):

        # Series
        series = float_frame.xs(float_frame.index[0])

        added = float_frame + series

        for key, s in added.items():
            tm.assert_series_equal(s, float_frame[key] + series[key])

        larger_series = series.to_dict()
        larger_series["E"] = 1
        larger_series = Series(larger_series)
        larger_added = float_frame + larger_series

        for key, s in float_frame.items():
            tm.assert_series_equal(larger_added[key], s + series[key])
        assert "E" in larger_added
        assert np.isnan(larger_added["E"]).all()

        # no upcast needed
        added = mixed_float_frame + series
        assert np.all(added.dtypes == series.dtype)

        # vs mix (upcast) as needed
        added = mixed_float_frame + series.astype("float32")
        _check_mixed_float(added, dtype=dict(C=None))
        added = mixed_float_frame + series.astype("float16")
        _check_mixed_float(added, dtype=dict(C=None))

        # FIXME: don't leave commented-out
        # these raise with numexpr.....as we are adding an int64 to an
        # uint64....weird vs int

        # added = mixed_int_frame + (100*series).astype('int64')
        # _check_mixed_int(added, dtype = dict(A = 'int64', B = 'float64', C =
        # 'int64', D = 'int64'))
        # added = mixed_int_frame + (100*series).astype('int32')
        # _check_mixed_int(added, dtype = dict(A = 'int32', B = 'float64', C =
        # 'int32', D = 'int64'))

        # TimeSeries
        ts = datetime_frame["A"]

        # 10890
        # we no longer allow auto timeseries broadcasting
        # and require explicit broadcasting
        added = datetime_frame.add(ts, axis="index")

        for key, col in datetime_frame.items():
            result = col + ts
            tm.assert_series_equal(added[key], result, check_names=False)
            assert added[key].name == key
            if col.name == ts.name:
                assert result.name == "A"
            else:
                assert result.name is None

        smaller_frame = datetime_frame[:-5]
        smaller_added = smaller_frame.add(ts, axis="index")

        tm.assert_index_equal(smaller_added.index, datetime_frame.index)

        smaller_ts = ts[:-5]
        smaller_added2 = datetime_frame.add(smaller_ts, axis="index")
        tm.assert_frame_equal(smaller_added, smaller_added2)

        # length 0, result is all-nan
        result = datetime_frame.add(ts[:0], axis="index")
        expected = DataFrame(
            np.nan, index=datetime_frame.index, columns=datetime_frame.columns
        )
        tm.assert_frame_equal(result, expected)

        # Frame is all-nan
        result = datetime_frame[:0].add(ts, axis="index")
        expected = DataFrame(
            np.nan, index=datetime_frame.index, columns=datetime_frame.columns
        )
        tm.assert_frame_equal(result, expected)

        # empty but with non-empty index
        frame = datetime_frame[:1].reindex(columns=[])
        result = frame.mul(ts, axis="index")
        assert len(result) == len(ts)

    def test_combineFunc(self, float_frame, mixed_float_frame):
        result = float_frame * 2
        tm.assert_numpy_array_equal(result.values, float_frame.values * 2)

        # vs mix
        result = mixed_float_frame * 2
        for c, s in result.items():
            tm.assert_numpy_array_equal(s.values, mixed_float_frame[c].values * 2)
        _check_mixed_float(result, dtype=dict(C=None))

        result = DataFrame() * 2
        assert result.index.equals(DataFrame().index)
        assert len(result.columns) == 0

    def test_comparisons(self, simple_frame, float_frame):
        df1 = tm.makeTimeDataFrame()
        df2 = tm.makeTimeDataFrame()

        row = simple_frame.xs("a")
        ndim_5 = np.ones(df1.shape + (1, 1, 1))

        def test_comp(func):
            result = func(df1, df2)
            tm.assert_numpy_array_equal(result.values, func(df1.values, df2.values))

            msg = (
                "Unable to coerce to Series/DataFrame, "
                "dimension must be <= 2: (30, 4, 1, 1, 1)"
            )
            with pytest.raises(ValueError, match=re.escape(msg)):
                func(df1, ndim_5)

            result2 = func(simple_frame, row)
            tm.assert_numpy_array_equal(
                result2.values, func(simple_frame.values, row.values)
            )

            result3 = func(float_frame, 0)
            tm.assert_numpy_array_equal(result3.values, func(float_frame.values, 0))

            msg = "Can only compare identically-labeled DataFrame"
            with pytest.raises(ValueError, match=msg):
                func(simple_frame, simple_frame[:2])

        test_comp(operator.eq)
        test_comp(operator.ne)
        test_comp(operator.lt)
        test_comp(operator.gt)
        test_comp(operator.ge)
        test_comp(operator.le)

    def test_strings_to_numbers_comparisons_raises(self, compare_operators_no_eq_ne):
        # GH 11565
        df = DataFrame(
            {x: {"x": "foo", "y": "bar", "z": "baz"} for x in ["a", "b", "c"]}
        )

        f = getattr(operator, compare_operators_no_eq_ne)
        msg = "'[<>]=?' not supported between instances of 'str' and 'int'"
        with pytest.raises(TypeError, match=msg):
            f(df, 0)

    def test_comparison_protected_from_errstate(self):
        missing_df = tm.makeDataFrame()
        missing_df.iloc[0]["A"] = np.nan
        with np.errstate(invalid="ignore"):
            expected = missing_df.values < 0
        with np.errstate(invalid="raise"):
            result = (missing_df < 0).values
        tm.assert_numpy_array_equal(result, expected)

    def test_boolean_comparison(self):

        # GH 4576
        # boolean comparisons with a tuple/list give unexpected results
        df = DataFrame(np.arange(6).reshape((3, 2)))
        b = np.array([2, 2])
        b_r = np.atleast_2d([2, 2])
        b_c = b_r.T
        lst = [2, 2, 2]
        tup = tuple(lst)

        # gt
        expected = DataFrame([[False, False], [False, True], [True, True]])
        result = df > b
        tm.assert_frame_equal(result, expected)

        result = df.values > b
        tm.assert_numpy_array_equal(result, expected.values)

        msg1d = "Unable to coerce to Series, length must be 2: given 3"
        msg2d = "Unable to coerce to DataFrame, shape must be"
        msg2db = "operands could not be broadcast together with shapes"
        with pytest.raises(ValueError, match=msg1d):
            # wrong shape
            df > lst

        with pytest.raises(ValueError, match=msg1d):
            # wrong shape
            result = df > tup

        # broadcasts like ndarray (GH#23000)
        result = df > b_r
        tm.assert_frame_equal(result, expected)

        result = df.values > b_r
        tm.assert_numpy_array_equal(result, expected.values)

        with pytest.raises(ValueError, match=msg2d):
            df > b_c

        with pytest.raises(ValueError, match=msg2db):
            df.values > b_c

        # ==
        expected = DataFrame([[False, False], [True, False], [False, False]])
        result = df == b
        tm.assert_frame_equal(result, expected)

        with pytest.raises(ValueError, match=msg1d):
            result = df == lst

        with pytest.raises(ValueError, match=msg1d):
            result = df == tup

        # broadcasts like ndarray (GH#23000)
        result = df == b_r
        tm.assert_frame_equal(result, expected)

        result = df.values == b_r
        tm.assert_numpy_array_equal(result, expected.values)

        with pytest.raises(ValueError, match=msg2d):
            df == b_c

        assert df.values.shape != b_c.shape

        # with alignment
        df = DataFrame(
            np.arange(6).reshape((3, 2)), columns=list("AB"), index=list("abc")
        )
        expected.index = df.index
        expected.columns = df.columns

        with pytest.raises(ValueError, match=msg1d):
            result = df == lst

        with pytest.raises(ValueError, match=msg1d):
            result = df == tup

    def test_inplace_ops_alignment(self):

        # inplace ops / ops alignment
        # GH 8511

        columns = list("abcdefg")
        X_orig = DataFrame(
            np.arange(10 * len(columns)).reshape(-1, len(columns)),
            columns=columns,
            index=range(10),
        )
        Z = 100 * X_orig.iloc[:, 1:-1].copy()
        block1 = list("bedcf")
        subs = list("bcdef")

        # add
        X = X_orig.copy()
        result1 = (X[block1] + Z).reindex(columns=subs)

        X[block1] += Z
        result2 = X.reindex(columns=subs)

        X = X_orig.copy()
        result3 = (X[block1] + Z[block1]).reindex(columns=subs)

        X[block1] += Z[block1]
        result4 = X.reindex(columns=subs)

        tm.assert_frame_equal(result1, result2)
        tm.assert_frame_equal(result1, result3)
        tm.assert_frame_equal(result1, result4)

        # sub
        X = X_orig.copy()
        result1 = (X[block1] - Z).reindex(columns=subs)

        X[block1] -= Z
        result2 = X.reindex(columns=subs)

        X = X_orig.copy()
        result3 = (X[block1] - Z[block1]).reindex(columns=subs)

        X[block1] -= Z[block1]
        result4 = X.reindex(columns=subs)

        tm.assert_frame_equal(result1, result2)
        tm.assert_frame_equal(result1, result3)
        tm.assert_frame_equal(result1, result4)

    def test_inplace_ops_identity(self):

        # GH 5104
        # make sure that we are actually changing the object
        s_orig = Series([1, 2, 3])
        df_orig = DataFrame(np.random.randint(0, 5, size=10).reshape(-1, 5))

        # no dtype change
        s = s_orig.copy()
        s2 = s
        s += 1
        tm.assert_series_equal(s, s2)
        tm.assert_series_equal(s_orig + 1, s)
        assert s is s2
        assert s._mgr is s2._mgr

        df = df_orig.copy()
        df2 = df
        df += 1
        tm.assert_frame_equal(df, df2)
        tm.assert_frame_equal(df_orig + 1, df)
        assert df is df2
        assert df._mgr is df2._mgr

        # dtype change
        s = s_orig.copy()
        s2 = s
        s += 1.5
        tm.assert_series_equal(s, s2)
        tm.assert_series_equal(s_orig + 1.5, s)

        df = df_orig.copy()
        df2 = df
        df += 1.5
        tm.assert_frame_equal(df, df2)
        tm.assert_frame_equal(df_orig + 1.5, df)
        assert df is df2
        assert df._mgr is df2._mgr

        # mixed dtype
        arr = np.random.randint(0, 10, size=5)
        df_orig = DataFrame({"A": arr.copy(), "B": "foo"})
        df = df_orig.copy()
        df2 = df
        df["A"] += 1
        expected = DataFrame({"A": arr.copy() + 1, "B": "foo"})
        tm.assert_frame_equal(df, expected)
        tm.assert_frame_equal(df2, expected)
        assert df._mgr is df2._mgr

        df = df_orig.copy()
        df2 = df
        df["A"] += 1.5
        expected = DataFrame({"A": arr.copy() + 1.5, "B": "foo"})
        tm.assert_frame_equal(df, expected)
        tm.assert_frame_equal(df2, expected)
        assert df._mgr is df2._mgr

    @pytest.mark.parametrize(
        "op",
        [
            "add",
            "and",
            "div",
            "floordiv",
            "mod",
            "mul",
            "or",
            "pow",
            "sub",
            "truediv",
            "xor",
        ],
    )
    def test_inplace_ops_identity2(self, op):

        if op == "div":
            return

        df = DataFrame({"a": [1.0, 2.0, 3.0], "b": [1, 2, 3]})

        operand = 2
        if op in ("and", "or", "xor"):
            # cannot use floats for boolean ops
            df["a"] = [True, False, True]

        df_copy = df.copy()
        iop = f"__i{op}__"
        op = f"__{op}__"

        # no id change and value is correct
        getattr(df, iop)(operand)
        expected = getattr(df_copy, op)(operand)
        tm.assert_frame_equal(df, expected)
        expected = id(df)
        assert id(df) == expected

    def test_alignment_non_pandas(self):
        index = ["A", "B", "C"]
        columns = ["X", "Y", "Z"]
        df = pd.DataFrame(np.random.randn(3, 3), index=index, columns=columns)

        align = pd.core.ops._align_method_FRAME
        for val in [
            [1, 2, 3],
            (1, 2, 3),
            np.array([1, 2, 3], dtype=np.int64),
            range(1, 4),
        ]:

            expected = DataFrame({"X": val, "Y": val, "Z": val}, index=df.index)
            tm.assert_frame_equal(align(df, val, "index")[1], expected)

            expected = DataFrame(
                {"X": [1, 1, 1], "Y": [2, 2, 2], "Z": [3, 3, 3]}, index=df.index
            )
            tm.assert_frame_equal(align(df, val, "columns")[1], expected)

        # length mismatch
        msg = "Unable to coerce to Series, length must be 3: given 2"
        for val in [[1, 2], (1, 2), np.array([1, 2]), range(1, 3)]:

            with pytest.raises(ValueError, match=msg):
                align(df, val, "index")

            with pytest.raises(ValueError, match=msg):
                align(df, val, "columns")

        val = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
        tm.assert_frame_equal(
            align(df, val, "index")[1],
            DataFrame(val, index=df.index, columns=df.columns),
        )
        tm.assert_frame_equal(
            align(df, val, "columns")[1],
            DataFrame(val, index=df.index, columns=df.columns),
        )

        # shape mismatch
        msg = "Unable to coerce to DataFrame, shape must be"
        val = np.array([[1, 2, 3], [4, 5, 6]])
        with pytest.raises(ValueError, match=msg):
            align(df, val, "index")

        with pytest.raises(ValueError, match=msg):
            align(df, val, "columns")

        val = np.zeros((3, 3, 3))
        msg = re.escape(
            "Unable to coerce to Series/DataFrame, dimension must be <= 2: (3, 3, 3)"
        )
        with pytest.raises(ValueError, match=msg):
            align(df, val, "index")
        with pytest.raises(ValueError, match=msg):
            align(df, val, "columns")

    def test_no_warning(self, all_arithmetic_operators):
        df = pd.DataFrame({"A": [0.0, 0.0], "B": [0.0, None]})
        b = df["B"]
        with tm.assert_produces_warning(None):
            getattr(df, all_arithmetic_operators)(b, 0)

def test_pow_with_realignment():
    # GH#32685 pow has special semantics for operating with null values
    left = pd.DataFrame({"A": [0, 1, 2]})
    right = pd.DataFrame(index=[0, 1, 2])

    result = left ** right
    expected = pd.DataFrame({"A": [np.nan, 1.0, np.nan]})
    tm.assert_frame_equal(result, expected)

# TODO: move to tests.arithmetic and parametrize
def test_pow_nan_with_zero():
    left = pd.DataFrame({"A": [np.nan, np.nan, np.nan]})
    right = pd.DataFrame({"A": [0, 0, 0]})

    expected = pd.DataFrame({"A": [1.0, 1.0, 1.0]})

    result = left ** right
    tm.assert_frame_equal(result, expected)

    result = left["A"] ** right["A"]
    tm.assert_series_equal(result, expected["A"])

def test_dataframe_series_extension_dtypes():
    # https://github.com/pandas-dev/pandas/issues/34311
    df = pd.DataFrame(np.random.randint(0, 100, (10, 3)), columns=["a", "b", "c"])
    ser = pd.Series([1, 2, 3], index=["a", "b", "c"])

    expected = df.to_numpy("int64") + ser.to_numpy("int64").reshape(-1, 3)
    expected = pd.DataFrame(expected, columns=df.columns, dtype="Int64")

    df_ea = df.astype("Int64")
    result = df_ea + ser
    tm.assert_frame_equal(result, expected)
    result = df_ea + ser.astype("Int64")
    tm.assert_frame_equal(result, expected)

def test_dataframe_blockwise_slicelike():
    # GH#34367
    arr = np.random.randint(0, 1000, (100, 10))
    df1 = pd.DataFrame(arr)
    df2 = df1.copy()
    df2.iloc[0, [1, 3, 7]] = np.nan

    df3 = df1.copy()
    df3.iloc[0, [5]] = np.nan

    df4 = df1.copy()
    df4.iloc[0, np.arange(2, 5)] = np.nan
    df5 = df1.copy()
    df5.iloc[0, np.arange(4, 7)] = np.nan

    for left, right in [(df1, df2), (df2, df3), (df4, df5)]:
        res = left + right

        expected = pd.DataFrame({i: left[i] + right[i] for i in left.columns})
        tm.assert_frame_equal(res, expected)

@pytest.mark.parametrize(
    "df, col_dtype",
    [
        (pd.DataFrame([[1.0, 2.0], [4.0, 5.0]], columns=list("ab")), "float64"),
        (pd.DataFrame([[1.0, "b"], [4.0, "b"]], columns=list("ab")), "object"),
    ],
)
def test_dataframe_operation_with_non_numeric_types(df, col_dtype):
    # GH #22663
    expected = pd.DataFrame([[0.0, np.nan], [3.0, np.nan]], columns=list("ab"))
    expected = expected.astype({"b": col_dtype})
    result = df + pd.Series([-1.0], index=list("a"))
    tm.assert_frame_equal(result, expected)

redpajama_set_name: RedPajamaGithub


text:
What to Do in Cool Lil' Wellington
Robert J Dickie
NZEDGE > News > Arts > Jono Kenyon To Star in Shonda Rhimes 'Toast'
Jono Kenyon To Star in Shonda Rhimes 'Toast'
Kiwi actor Jono Kenyon has landed the male lead in Toast – ABC's hybrid comedy pilot from Shonda Rhimes and Betsy Beers' Shondaland – alongside Grey's Anatomy alumna Tessa Ferrer.
"So excited to announce my next project! Lead role in an ABC comedy pilot produced by Shonda Rhimes (Grey's Anatomy, Scandal etc.) 6 weeks in LA and dreams coming true… stay tuned," the Kiwi actor posted on Instagram.
The comedy "revolves around engaged couple Max Leeds (Kenyon) and Paige (not yet cast)", whose families give toasts recalling anecdotes about the couple over their wedding rehearsal dinner.
In flashbacks we are told the true story of their "complicated, funny and relatable road to marriage", which turns out to be quite different from the families' recollections.
Ferrer stars as Max's closest friend and is worried that he might be too focused on the wrong things when it comes to meeting the right woman.
The new series was written by Scott Foley and Greg Grunberg and directed by Gail Mancuso. It will be Kenyon's first Hollywood gig.
Jono Kenyon is an actor from Auckland, New Zealand. He is most well-known for playing the title role in the popular New Zealand comedy-drama series Step Dave.
Article Source: Deadline, Nellie Andreeva, March 8, 2016
Image Source: Twitter – Jono Kenyon
Tags: AMC Deadline Grey's Anatomy Jono Kenyon Scandel Shonda Rimes TOAST
Taika Waititi Explains Our Sense of Humour
Rose Matafeo to Star in Taika Waititi Exec Produced 'Baby, Done'
Ava DuVernay's ARRAY Picks Up Merata Doco
Taika Waititi Speaks at Toronto Master Class


text:
namespace vr {

class UiElement;
class UiScene;
struct Model;

class UiTest : public testing::Test {
 public:
  UiTest();
  ~UiTest() override;

  void SetUp() override;

 protected:
  enum InWebVr : bool {
    kNotInWebVr = false,
    kInWebVr = true,
  };

  enum WebVrAutopresented : bool {
    kNotAutopresented = false,
    kAutopresented = true,
  };

  void CreateScene(const UiInitialState& state);
  void CreateScene(InWebVr in_web_vr);

 protected:
  void CreateSceneInternal(
      const UiInitialState& state,
      std::unique_ptr<MockContentInputDelegate> content_input_delegate);

  void SetIncognito(bool incognito);

  // Check whether a named element is visible. In this test, visibilility is the
  // target visibily, not the current (possibly animating) visibility. This
  // makes it easier to test the visibility of elements in response to state
  // changes.
  bool IsVisible(UiElementName name) const;

  // Return false if not all elements in the set match the specified visibility
  // state. Other elements are ignored.
  bool VerifyVisibility(const std::set<UiElementName>& names,
                        bool visible) const;

  // Check that only a specific set of elements is visible, and others are not.
  void VerifyOnlyElementsVisible(const std::string& trace_context,
                                 const std::set<UiElementName>& names) const;

  // Count the number of elements in the named element's subtree.
  int NumVisibleInTree(UiElementName name) const;

  // Return false if not all elements in the set match the specified |animating|
  // state for the specified |properties|. Other elements are ignored.
  bool VerifyIsAnimating(const std::set<UiElementName>& names,
                         const std::vector<TargetProperty>& properties,
                         bool animating) const;

  // Return false if not all elements in the set match the specified requires
  // layout state. Other elements are ignored.
  bool VerifyRequiresLayout(const std::set<UiElementName>& names,
                            bool requires_layout) const;

  // Check if element is using correct opacity in Render recursively.
  void CheckRendererOpacityRecursive(UiElement* element);

  // Advances current_time_ by delta. This is done by running the next frame,
  // then jumping time ahead to the final time. Generally, the UI should not
  // require all intermediate frames to be called. Tests that require this
  // should simulate the required intermediate frames.
  bool RunForMs(float milliseconds);
  bool RunForSeconds(float seconds);

  // Advances time by one frame (16 ms) and calls 'OnBeginFrame()'
  bool AdvanceFrame();

  void GetBackgroundColor(SkColor* background_color) const;

  // Synthesize a controller orientation that intersects the element, and cycle
  // the controller button.  This offers a reasonably correct means of testing
  // clicks on elements, that's true to hit testability, visbility, etc.
  void ClickElement(UiElement* element);

  std::unique_ptr<Ui> ui_instance_;
  raw_ptr<UiInterface> ui_ = nullptr;
  std::unique_ptr<MockUiBrowserInterface> browser_;
  raw_ptr<MockContentInputDelegate> content_input_delegate_ = nullptr;
  raw_ptr<Model> model_ = nullptr;
  raw_ptr<UiScene> scene_ = nullptr;

 private:
  bool RunFor(base::TimeDelta delta);
  bool OnBeginFrame() const;

  base::TimeTicks current_time_;
};

}  // namespace vr

#endif  // CHROME_BROWSER_VR_TEST_UI_TEST_H_


Suzuki Philippines Inc. (SPH), the exclusive local distributor of Suzuki automobiles, confirmed that an updated version of the Alto is now available in the country. It features a refreshed front fascia, but retains its compact size that's perfect for the city streets.
The most noticeable update on the new Suzuki Alto is its front trapezoidal lower grille, a departure from the previous hexagonal form. Moreover, the bulb configuration of the sweptback headlamps has also been updated.
In addition, the upper grille is slimmer as compared to the older model. This made the Suzuki emblem more prominent as it's situated between the upper and lower grilles, adding a refreshing appeal to the car. To complete the changes upfront, the new Suzuki Alto has been equipped with fog lamps.
In profile, the new Alto has also been fitted with side rubber cladding, which adds protection against side swipes in case you end up in a tight situation with this hatchback. The rear end, though, didn't receive any changes with this update.
The interior of the new Alto remains the same, with essentials such as a 1-DIN head unit with radio, CD, and MP3, as well as power windows, and manual air conditioning.
As for the engine, it will still be powered by the 3-cylinder 0.8L gasoline engine that's capable of producing 47 hp and 68 Nm of torque. It's then mated to a 5-speed manual transmission that transfers the power to the front wheels.
The new Suzuki Alto is now available in your local showrooms at a price tag of P398,000 for the Standard variant, while the Deluxe variant sells at P438,000.
For more information about the new Suzuki Alto, visit the AutoDeal Car Guide.
Hi, I would like to receive a financing quote for the Suzuki Alto, thank you.


text:
Gladys Marie Long[1]
Personal Information | Media | Sources | Event Map | All | PDF
Name Gladys Marie Long
Born 27 Nov 1922 Argenta, Live Oak Co., Texas [1, 2]
Died 7 Oct 2014 Rogers, Benton Co., Arkansas [2]
Buried 13 Oct 2014 Roselawn Memorial Park Cemetery, Alice, Jim Wells Co., Texas [3, 4]
Gladys Marie Long Winkler (1922-2014) - Find A Grave Memorial
FamilySearch ID LN76-Q69
Father James Creddie Long
Mother Effie Jewel Bradfute
Family 1 Lowel Reed Cooper, b. 12 Jun 1907, Nixon, Gonzales Co., Texas , d. May 1984, Nixon, Gonzales Co., Texas (Age 76 years) [1, 3, 5]
+ 1. Peggy Rae Cooper
Family 2 Isidor Antion "Easy" Winkler, b. 28 Apr 1923, d. 26 Aug 1984, Mathis, San Patricio Co., Texas (Age 61 years) [1, 6]
Married 23 Apr 1943
+ 1. Raymond Louis Winkler, Sr.
+ 2. Albert Elwood "Woody" Winkler
3. James Archie Winkler
+ 4. Valerie Jean Winkler
+ 5. Jacqueline Marie "Jackie" Winkler
6. Janet Winkler
Family 3 Horace J. Hines, b. 4 Oct 1916, d. 8 Mar 2000, Bandera, Bandera Co., Texas (Age 83 years) [1, 3, 7]
Married 15 Dec 1990 Church of Christ, Mathis, San Patricio Co., Texas
Born - 27 Nov 1922 - Argenta, Live Oak Co., Texas
Married - 15 Dec 1990 - Church of Christ, Mathis, San Patricio Co., Texas
Died - 7 Oct 2014 - Rogers, Benton Co., Arkansas
Buried - 13 Oct 2014 - Roselawn Memorial Park Cemetery, Alice, Jim Wells Co., Texas
Gladys Long Winkler
[S291] Family Information from Jackie Winkler Grice, [Winkler pp. 5, 7].
[S959] Obituary of Gladys Long Winkler, [Winkler p. 153].
Gladys Long Winkler, 91, passed away Tuesday, October 7, 2014, at her home in Rogers, Arkansas. She was born November 27, 1922 in Argenta, Texas to the late Creddie and Effie Long.
Gladys was preceded in death by three husbands; Lowell Cooper, Isadore (Easy) Winkler and Horace Hines; three sisters; Elna Sciba, Bonnie Wiater and LyNell Grimes; one brother, Orvis Long; and one grandson, Paul Winkler.
She is survived by seven children; Peggy (Lendal) Wilks, Louis (Janet) Winkler, Woody (Sue) Winkler, Archie (Rita) Winkler, Valerie Davis, Jackie Winkler and Janet (Sandra Horine) Winkler; 12 grandchildren, 18 great-grandchildren, and five great-great grandchildren.
Visitation will be held Sunday, October 12, 2014 from 5 p.m. to 7 p.m. at Holmgreen Mortuary, Alice, Texas. A celebration of her life will be held at 11 a.m. Monday, October 13, 2014 at Holmgreen Mortuary Chapel, 2061 East Main St., Alice, Texas. Burial will follow at Roselawn Memorial Park.
In lieu of flowers, donations may be sent to Namikango Mission, PO Box 21, South Houston, Texas 77587. Arrangements are entrusted to Holmgreen Mortuary, 2061 East Main St. Alice, Texas 78332.
Condolences may be offered at www.holmgreenmortuaryinc.com
[S940] Find A Grave, 12 October 2014; http://www.findagrave.com/cgi-bin/fg.cgi?page=gr&GRid=41000583.
Gladys Marie Long Winkler; Birth: 1922, Texas, USA; Death: unknown; Note: Daughter of Walter E. (born abt 1894, TN) & Daisy E. (born abt 1900, TX) LONG, 1930 San Saba Co. Born TX; Spouse: Isidor Anton Winkler (1923 - 1984); Note: Shared stone with Isidor A. Winkler; Burial: Roselawn Memorial Park, Alice, Jim Wells County, Texas, USA; Created by: Charlie Ward; Record added: Aug 22, 2009; Find A Grave Memorial# 41000583.
[S291] Family Information from Jackie Winkler Grice, [Winkler p. 9].
[S31] Family Information from Bridgit Winkler, [Winkler p. 1].
Written in Polish.
Date: not dated